进程隔离是为保护操作系统中进程互不干扰而设计的一组不同硬件和软件的技术。这个技术是为了避免进程A写入进程B的情况发生。 进程的隔离实现，使用了虚拟地址空间。进程A的虚拟地址和进程B的虚拟地址不同，这样就防止进程A将数据信息写入进程B。

Kernel space can be accessed by user processes only through the use of system calls.

驱动程序一般指的是设备驱动程序（Device Driver），是一种可以使计算机和设备通信的特殊程序。相当于硬件的接口，操作系统只有通过这个接口，才能控制硬件设备的工作；

B -> 12345676  C -> 12334354

先查阅通信录，拿到B的号码；才能进行通信；否则，怎么知道应该拨什么号码？回想一下古老的电话机，如果A要给B打电话，必须先连接通话中心，说明给我接通B的电话；这时候通话中心帮他呼叫B；连接建立，就完成了通信。

另外，光有电话和通信录是不可能完成通信的，没有基站支持；信息根本无法传达。

我们看到，一次电话通信的过程除了通信的双方还有两个隐藏角色：通信录和基站。Binder通信机制也是一样：两个运行在用户空间的进程要完成通信，必须借助内核的帮助，这个运行在内核里面的程序叫做 Binder驱动 ，它的功能类似于基站；通信录呢，就是一个叫做 ServiceManager 的东西（简称SM）

OK，Binder的通信模型就是这么简单，如下图：

整个通信步骤如下：

1. SM建立(建立通信录)；首先有一个进程向驱动提出申请为SM；驱动同意之后，SM进程负责管理Service（注意这里是Service而不是Server，因为如果通信过程反过来的话，那么原来的客户端Client也会成为服务端Server）不过这时候通信录还是空的，一个号码都没有。
2. 各个Server向SM注册(完善通信录)；每个Server端进程启动之后，向SM报告，我是zhangsan, 要找我请返回0x1234(这个地址没有实际意义，类比)；其他Server进程依次如此；这样SM就建立了一张表，对应着各个Server的名字和地址；就好比B与A见面了，说存个我的号码吧，以后找我拨打10086；
3. Client想要与Server通信，首先询问SM；请告诉我如何联系zhangsan，SM收到后给他一个号码0x1234；Client收到之后，开心滴用这个号码拨通了Server的电话，于是就开始通信了。

那么Binder驱动干什么去了呢？这里Client与SM的通信，以及Client与Server的通信，都会经过驱动，驱动在背后默默无闻，但是做着最重要的工作。驱动是整个通信过程的核心，因此完成跨进程通信的秘密全部隐藏在驱动里面；这个我们稍后讨论。

OK，上面就是整个Binder通信的基本模型；做了一个简单的类比，当然也有一些不恰当的地方，(比如通信录现实中每个人都有一个，但是SM整个系统只有一个；基站也有很多个，但是驱动只有一个）；但是整体上就是这样的；我们看到其实整个通信模型非常简单。

Binder机制跨进程原理

上文给出了Binder的通信模型，指出了通信过程的四个角色: Client, Server, SM, driver; 但是我们仍然不清楚 Client到底是如何与Server完成通信的 。

两个运行在用户空间的进程A和进程B如何完成通信呢？内核可以访问A和B的所有数据；所以，最简单的方式是通过内核做中转；假设进程A要给进程B发送数据，那么就先把A的数据copy到内核空间，然后把内核空间对应的数据copy到B就完成了；用户空间要操作内核空间，需要通过系统调用；刚好，这里就有两个系统调用： copy_from_user , copy_to_user 。

但是，Binder机制并不是这么干的。讲这么一段，是说明进程间通信并不是什么神秘的东西。那么，Binder机制是如何实现跨进程通信的呢？

Binder驱动为我们做了一切。

假设Client进程想要调用Server进程的 object 对象的一个方法 add ;对于这个跨进程通信过程，我们来看看Binder机制是如何做的。 （通信是一个广泛的概念，只要一个进程能调用另外一个进程里面某对象的方法，那么具体要完成什么通信内容就很容易了。）

首先，Server进程要向SM注册；告诉自己是谁，自己有什么能力；在这个场景就是Server告诉SM，它叫 zhangsan ，它有一个 object 对象，可以执行 add 操作；于是SM建立了一张表： zhangsan 这个名字对应进程Server;

然后Client向SM查询：我需要联系一个名字叫做 zhangsan 的进程里面的 object 对象；这时候关键来了：进程之间通信的数据都会经过运行在内核空间里面的驱动，驱动在数据流过的时候做了一点手脚，它并不会给Client进程返回一个真正的 object 对象，而是返回一个看起来跟 object 一模一样的代理对象 objectProxy ，这个 objectProxy 也有一个 add 方法，但是这个 add 方法没有Server进程里面 object 对象的 add 方法那个能力； objectProxy 的 add 只是一个傀儡，它唯一做的事情就是把参数包装然后交给驱动。(这里我们简化了SM的流程，见下文)

但是Client进程并不知道驱动返回给它的对象动过手脚，毕竟伪装的太像了，如假包换。Client开开心心地拿着 objectProxy 对象然后调用 add 方法；我们说过，这个 add 什么也不做，直接把参数做一些包装然后直接转发给Binder驱动。

驱动收到这个消息，发现是这个 objectProxy ；一查表就明白了：我之前用 objectProxy 替换了 object 发送给Client了，它真正应该要访问的是 object 对象的 add 方法；于是Binder驱动通知Server进程， 调用你的object对象的 add 方法，然后把结果发给我 ，Sever进程收到这个消息，照做之后将结果返回驱动，驱动然后把结果返回给 Client 进程；于是整个过程就完成了。

由于驱动返回的 objectProxy 与Server进程里面原始的 object 是如此相似，给人感觉好像是 直接把Server进程里面的对象object传递到了Client进程 ；因此，我们可以说 Binder对象是可以进行跨进程传递的对象

但事实上我们知道，Binder跨进程传输并不是真的把一个对象传输到了另外一个进程；传输过程好像是Binder跨进程穿越的时候，它在一个进程留下了一个真身，在另外一个进程幻化出一个影子（这个影子可以很多个）；Client进程的操作其实是对于影子的操作，影子利用Binder驱动最终让真身完成操作。

理解这一点非常重要；务必仔细体会。另外，Android系统实现这种机制使用的是 代理模式 , 对于Binder的访问，如果是在同一个进程（不需要跨进程），那么直接返回原始的Binder实体；如果在不同进程，那么就给他一个代理对象（影子）；我们在系统源码以及AIDL的生成代码里面可以看到很多这种实现。

另外我们为了简化整个流程，隐藏了SM这一部分驱动进行的操作；实际上，由于SM与Server通常不在一个进程，Server进程向SM注册的过程也是跨进程通信，驱动也会对这个过程进行暗箱操作：SM中存在的Server端的对象实际上也是代理对象，后面Client向SM查询的时候，驱动会给Client返回另外一个代理对象。Sever进程的本地对象仅有一个，其他进程所拥有的全部都是它的代理。

一句话总结就是： Client进程只不过是持有了Server端的代理；代理对象协助驱动完成了跨进程通信。

OK，该休息一下了。

Binder到底是什么？

我们经常提到Binder，那么Binder到底是什么呢？

Binder的设计采用了面向对象的思想，在Binder通信模型的四个角色里面；他们的代表都是“Binder”，这样，对于Binder通信的使用者而言，Server里面的Binder和Client里面的Binder没有什么不同，一个Binder对象就代表了所有，它不用关心实现的细节，甚至不用关心驱动以及SM的存在；这就是抽象。

• 通常意义下，Binder指的是一种通信机制；我们说AIDL使用Binder进行通信，指的就是 Binder这种IPC机制 。
• 对于Server进程来说，Binder指的是 Binder本地对象
• 对于Client来说，Binder指的是 Binder代理对象 ，它只是 Binder本地对象 的一个远程代理；对这个Binder代理对象的操作，会通过驱动最终转发到Binder本地对象上去完成；对于一个拥有Binder对象的使用者而言，它无须关心这是一个Binder代理对象还是Binder本地对象；对于代理对象的操作和对本地对象的操作对它来说没有区别。
• 对于传输过程而言，Binder是可以进行跨进程传递的对象；Binder驱动会对具有跨进程传递能力的对象做特殊处理：自动完成代理对象和本地对象的转换。

驱动里面的Binder

我们现在知道，Server进程里面的Binder对象指的是Binder本地对象，Client里面的对象值得是Binder代理对象；在Binder对象进行跨进程传递的时候，Binder驱动会自动完成这两种类型的转换；因此Binder驱动必然保存了每一个跨越进程的Binder对象的相关信息；在驱动中，Binder本地对象的代表是一个叫做 binder_node 的数据结构，Binder代理对象是用 binder_ref 代表的；有的地方把Binder本地对象直接称作Binder实体，把Binder代理对象直接称作Binder引用（句柄），其实指的是Binder对象在驱动里面的表现形式；读者明白意思即可。

OK，现在大致了解Binder的通信模型，也了解了Binder这个对象在通信过程中各个组件里面到底表示的是什么。

深入理解Java层的Binder

IBinder/IInterface/Binder/BinderProxy/Stub

我们使用AIDL接口的时候，经常会接触到这些类，那么这每个类代表的是什么呢？

• IBinder是一个接口，它代表了 一种跨进程传输的能力 ；只要实现了这个接口，就能将这个对象进行跨进程传递；这是驱动底层支持的；在跨进程数据流经驱动的时候，驱动会识别IBinder类型的数据，从而自动完成不同进程Binder本地对象以及Binder代理对象的转换。
• IBinder负责数据传输，那么client与server端的调用契约（这里不用接口避免混淆）呢？这里的IInterface代表的就是远程server对象具有什么能力。具体来说，就是aidl里面的接口。
• Java层的Binder类，代表的其实就是 Binder本地对象 。BinderProxy类是Binder类的一个内部类，它代表远程进程的Binder对象的本地代理；这两个类都继承自IBinder, 因而都具有跨进程传输的能力；实际上，在跨越进程的时候，Binder驱动会自动完成这两个对象的转换。
• 在使用AIDL的时候，编译工具会给我们生成一个Stub的静态内部类；这个类继承了Binder, 说明它是一个Binder本地对象，它实现了IInterface接口，表明它具有远程Server承诺给Client的能力；Stub是一个抽象类，具体的IInterface的相关实现需要我们手动完成，这里使用了策略模式。

AIDL过程分析

现在我们通过一个AIDL的使用，分析一下整个通信过程中，各个角色到底做了什么，AIDL到底是如何完成通信的。（如果你连AIDL都不熟悉，请先查阅官方文档）

首先定一个一个简单的aidl接口：

// ICompute.aidl  package com.example.test.app;  interface ICompute {       int add(int a, int b);  }

package com.example.test.app;    public interface ICompute extends android.os.IInterface {      /**       * Local-side IPC implementation stub class.       */      public static abstract class Stub extends android.os.Binder implements com.example.test.app.ICompute {          private static final java.lang.String DESCRIPTOR = "com.example.test.app.ICompute";            /**           * Construct the stub at attach it to the interface.           */          public Stub() {              this.attachInterface(this, DESCRIPTOR);          }            /**           * Cast an IBinder object into an com.example.test.app.ICompute interface,           * generating a proxy if needed.           */          public static com.example.test.app.ICompute asInterface(android.os.IBinder obj) {              if ((obj == null)) {                  return null;              }              android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);              if (((iin != null) && (iin instanceof com.example.test.app.ICompute))) {                  return ((com.example.test.app.ICompute) iin);              }              return new com.example.test.app.ICompute.Stub.Proxy(obj);          }            @Override          public android.os.IBinder asBinder() {              return this;          }            @Override          public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException {              switch (code) {                  case INTERFACE_TRANSACTION: {                      reply.writeString(DESCRIPTOR);                      return true;                  }                  case TRANSACTION_add: {                      data.enforceInterface(DESCRIPTOR);                      int _arg0;                      _arg0 = data.readInt();                      int _arg1;                      _arg1 = data.readInt();                      int _result = this.add(_arg0, _arg1);                      reply.writeNoException();                      reply.writeInt(_result);                      return true;                  }              }              return super.onTransact(code, data, reply, flags);          }            private static class Proxy implements com.example.test.app.ICompute {              private android.os.IBinder mRemote;                Proxy(android.os.IBinder remote) {                  mRemote = remote;              }                @Override              public android.os.IBinder asBinder() {                  return mRemote;              }                public java.lang.String getInterfaceDescriptor() {                  return DESCRIPTOR;              }                /**               * Demonstrates some basic types that you can use as parameters               * and return values in AIDL.               */              @Override              public int add(int a, int b) throws android.os.RemoteException {                  android.os.Parcel _data = android.os.Parcel.obtain();                  android.os.Parcel _reply = android.os.Parcel.obtain();                  int _result;                  try {                      _data.writeInterfaceToken(DESCRIPTOR);                      _data.writeInt(a);                      _data.writeInt(b);                      mRemote.transact(Stub.TRANSACTION_add, _data, _reply, 0);                      _reply.readException();                      _result = _reply.readInt();                  } finally {                      _reply.recycle();                      _data.recycle();                  }                  return _result;              }          }            static final int TRANSACTION_add = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);      }        /**       * Demonstrates some basic types that you can use as parameters       * and return values in AIDL.       */      public int add(int a, int b) throws android.os.RemoteException;  }

/**           * Cast an IBinder object into an com.example.test.app.ICompute interface,           * generating a proxy if needed.           */          public static com.example.test.app.ICompute asInterface(android.os.IBinder obj) {              if ((obj == null)) {                  return null;              }              android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);              if (((iin != null) && (iin instanceof com.example.test.app.ICompute))) {                  return ((com.example.test.app.ICompute) iin);              }              return new com.example.test.app.ICompute.Stub.Proxy(obj);          }

Override              public int add(int a, int b) throws android.os.RemoteException {                  android.os.Parcel _data = android.os.Parcel.obtain();                  android.os.Parcel _reply = android.os.Parcel.obtain();                  int _result;                  try {                      _data.writeInterfaceToken(DESCRIPTOR);                      _data.writeInt(a);                      _data.writeInt(b);                      mRemote.transact(Stub.TRANSACTION_add, _data, _reply, 0);                      _reply.readException();                      _result = _reply.readInt();                  } finally {                      _reply.recycle();                      _data.recycle();                  }                  return _result;              }

public native boolean transact(int code, Parcel data, Parcel reply,              int flags) throws RemoteException;

@Override          public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException {              switch (code) {                  case INTERFACE_TRANSACTION: {                      reply.writeString(DESCRIPTOR);                      return true;                  }                  case TRANSACTION_add: {                      data.enforceInterface(DESCRIPTOR);                      int _arg0;                      _arg0 = data.readInt();                      int _arg1;                      _arg1 = data.readInt();                      int _result = this.add(_arg0, _arg1);                      reply.writeNoException();                      reply.writeInt(_result);                      return true;                  }              }              return super.onTransact(code, data, reply, flags);          }