在谈Android的跨进程通讯问题上时，总会问到Android的IPC机制，是指两个进程之间进行数据交换的过程。按操做系统的中的描述，线程是CPU调度最小的单元，同时线程是一种有限的系统资源，而进程是指一个执行单元，在PC和移动设备上指一个程序或者一个应用。java

在谈IPC机制时候核心的就是Binder的运做原理，本文将从如下几点来说Android额Binder原理。
android

什么是Binder

关于Binder的定义，网上是这样的：Binder是跨进程通讯方式、它实现了IBinder接口，是链接 ServiceManager的桥梁。不过这句话有点抽象，那Binder到底是什么呢？或许下面的图能解答你心中的疑惑。
web

基础概念

进程空间分配

在Linux的进程模型中，进程空间被分为用户空间和内核空间（Kernel），即把进程内用户和内核隔离开来，其中用户空间的数据不可共享，而内核空间是可共享的，因此进程间的通讯主要经过内核进行交互，称为系统调用。模型示意图以下：
安全

Android跨进程通讯（ IPC ）

在Android的进程模型中，一个进程不能直接操做或者访问另外一个进程，即Android的进程是相互独立、隔离的。但Android的进程通讯继承自Linux，因此Android的进程通讯能够经过内核空间进行数据交互，在进而经过进程的用户空间与内核空间进行数据交互，最终时间进程之间的通讯。模型示意图以下：
多线程

而Binder的做用就是链接两个进程内核空间的通道。架构

Binder 跨进程通讯原理

Binder跨进程通讯机制模型基于 Client - Server 模式，其原理模型以下图所示：

经过该模型能够发现：
Client进程、Server进程 & Service Manager 进程之间的交互都必须经过Binder驱动（使用 open 和 ioctl文件操做函数），而非直接交互。并发

其中：Client进程、Server进程 & Service Manager进程属于进程空间的用户空间，不可进行进程间交互；Binder驱动属于进程空间的内核空间，可进行进程间 & 进程内交互。
ide

说明：Binder驱动 & Service Manager进程属于 Android基础架构（即系统已经实现好了）；而Client 进程和 Server 进程属于Android应用层（须要开发者本身实现）。因此，在进行跨进程通讯时，开发者只需自定义Client & Server 进程并显式使用上述3个步骤，最终借助 Android的基本架构功能就可完成进程间通讯。
svg

说明：Binder请求的线程管理函数

Server进程会建立不少线程来处理Binder请求；
管理Binder模型的线程是采用Binder驱动的线程池，并由Binder驱动自身进行管理，而不是由Server进程来管理的；
一个进程的Binder线程数默认最大是16，超过的请求会被阻塞等待空闲的Binder线程，因此，在进程间通讯时处理并发问题时，如使用ContentProvider时，它的CRUD（建立、检索、更新和删除）方法只能同时有16个线程同时工做。

Binder机制具体实现

Binder机制在 Android中的实现主要依靠 Binder类，其实现了IBinder 接口。例如，下面是Client进程调用Server进程的实现加法函数的实例。即Client进程须要传两个整数给 Server进程，Server进程把相加后的结果返回给Client进程。

1，注册服务

Server进程经过Binder驱动向 Service Manager进程注册服务，Server进程建立一个 Binder 对象，其中Binder 实体是 Server进程在 Binder 驱动中的具体存在形式，该对象保存 Server 和 ServiceManager 的信息，Binder 驱动经过内核空间的Binder实体找到用户空间的Server对象。下面是具体的代码实现：

Binder binder = new Stub();
    // 步骤1：建立Binder对象 ->>分析1

    // 步骤2：建立 IInterface 接口类 的匿名类
    // 建立前，须要预先定义 继承了IInterface 接口的接口 -->分析3
    IInterface plus = new IPlus(){

          // 肯定Client进程须要调用的方法
          public int add(int a,int b) {
               return a+b;
         }

          // 实现IInterface接口中惟一的方法
          public IBinder asBinder（）{ 
                return null ;
           }
};
          // 步骤3
          binder.attachInterface(plus，"add two int");
         // 1. 将（add two int，plus）做为（key,value）对存入到Binder对象中的一个Map<String,IInterface>对象中
         // 2. 以后，Binder对象 可根据add two int经过queryLocalIInterface（）得到对应IInterface对象（即plus）的引用，可依靠该引用完成对请求方法的调用
        // 分析完毕，跳出


<-- 分析1：Stub类 -->
    public class Stub extends Binder { 
 
   
    // 继承自Binder类 ->>分析2

          // 复写onTransact（）
          @Override
          boolean onTransact(int code, Parcel data, Parcel reply, int flags){
          // 具体逻辑等到步骤3再具体讲解，此处先跳过
          switch (code) { 
                case Stub.add： { 

                       data.enforceInterface("add two int"); 

                       int  arg0  = data.readInt();
                       int  arg1  = data.readInt();

                       int  result = this.queryLocalIInterface("add two int") .add( arg0,  arg1); 

                        reply.writeInt(result); 

                        return true; 
                  }
           } 
      return super.onTransact(code, data, reply, flags); 

}
// 回到上面的步骤1，继续看步骤2

<-- 分析2：Binder 类 -->
 public class Binder implement IBinder{ 
 
   
    // Binder机制在Android中的实现主要依靠的是Binder类，其实现了IBinder接口
    // IBinder接口：定义了远程操做对象的基本接口，表明了一种跨进程传输的能力
    // 系统会为每一个实现了IBinder接口的对象提供跨进程传输能力
    // 即Binder类对象具有了跨进程传输的能力

        void attachInterface(IInterface plus, String descriptor)；
        // 做用：
          // 1. 将（descriptor，plus）做为（key,value）对存入到Binder对象中的一个Map<String,IInterface>对象中
          // 2. 以后，Binder对象 可根据descriptor经过queryLocalIInterface（）得到对应IInterface对象（即plus）的引用，可依靠该引用完成对请求方法的调用

        IInterface queryLocalInterface(Stringdescriptor) ；
        // 做用：根据 参数 descriptor 查找相应的IInterface对象（即plus引用）

        boolean onTransact(int code, Parcel data, Parcel reply, int flags)；
        // 定义：继承自IBinder接口的
        // 做用：执行Client进程所请求的目标方法（子类须要复写）
        // 参数说明：
        // code：Client进程请求方法标识符。即Server进程根据该标识肯定所请求的目标方法
        // data：目标方法的参数。（Client进程传进来的，此处就是整数a和b）
        // reply：目标方法执行后的结果（返回给Client进程）
         // 注：运行在Server进程的Binder线程池中；当Client进程发起远程请求时，远程请求会要求系统底层执行回调该方法

        final class BinderProxy implements IBinder { 
 
   
         // 即Server进程建立的Binder对象的代理对象类
         // 该类属于Binder的内部类
        }
        // 回到分析1原处
}

<-- 分析3：IInterface接口实现类 -->

 public interface IPlus extends IInterface { 
 
   
          // 继承自IInterface接口->>分析4
          // 定义须要实现的接口方法，即Client进程须要调用的方法
         public int add(int a,int b);
// 返回步骤2
}

<-- 分析4：IInterface接口类 -->
// 进程间通讯定义的通用接口
// 经过定义接口，而后再服务端实现接口、客户端调用接口，就可实现跨进程通讯。
public interface IInterface { 
 
   
    // 只有一个方法：返回当前接口关联的 Binder 对象。
    public IBinder asBinder();
}
  // 回到分析3原处
注册服务后，Binder驱动持有 Server进程建立的Binder实体

2，获取服务

Client进程使用某个service前，须经过Binder驱动向 ServiceManager进程获取相应的Service信息。可使用下面的图来表示:

3，使用服务

Client进程根据获取到的 Service信息（Binder代理对象），经过Binder驱动创建与该Service所在Server进程通讯的链路，并开始使用服务。具体的，Client进程将参数发送到Server进程，Server进程根据Client进程要求调用目标方法，并将目标方法的结果返回给Client进程。代码实现以下：

步骤1： Client进程 将参数（整数a和b）发送到Server进程

// 1. Client进程 将须要传送的数据写入到Parcel对象中
// data = 数据 = 目标方法的参数（Client进程传进来的，此处就是整数a和b） + IInterface接口对象的标识符descriptor
  android.os.Parcel data = android.os.Parcel.obtain();
  data.writeInt(a); 
  data.writeInt(b); 

  data.writeInterfaceToken("add two int");；
  // 方法对象标识符让Server进程在Binder对象中根据"add two int"经过queryLocalIInterface（）查找相应的IInterface对象（即Server建立的plus），Client进程须要调用的相加方法就在该对象中

  android.os.Parcel reply = android.os.Parcel.obtain();
  // reply：目标方法执行后的结果（此处是相加后的结果）

// 2. 经过 调用代理对象的transact（） 将 上述数据发送到Binder驱动
  binderproxy.transact(Stub.add, data, reply, 0)
  // 参数说明：
    // 1. Stub.add：目标方法的标识符（Client进程 和 Server进程 自身约定，可为任意）
    // 2. data ：上述的Parcel对象
    // 3. reply：返回结果
    // 0：可无论

// 注：在发送数据后，Client进程的该线程会暂时被挂起
// 因此，若Server进程执行的耗时操做，请不要使用主线程，以防止ANR


// 3. Binder驱动根据 代理对象 找到对应的真身Binder对象所在的Server 进程（系统自动执行）
// 4. Binder驱动把 数据 发送到Server 进程中，并通知Server 进程执行解包（系统自动执行）
步骤2：Server进程根据Client进要求 调用 目标方法（即加法函数）

// 1. 收到Binder驱动通知后，Server 进程经过回调Binder对象onTransact（）进行数据解包 & 调用目标方法
  public class Stub extends Binder { 
 
   

          // 复写onTransact（）
          @Override
          boolean onTransact(int code, Parcel data, Parcel reply, int flags){
          // code即在transact（）中约定的目标方法的标识符

          switch (code) { 
                case Stub.add： { 
                  // a. 解包Parcel中的数据
                       data.enforceInterface("add two int"); 
                        // a1. 解析目标方法对象的标识符

                       int  arg0  = data.readInt();
                       int  arg1  = data.readInt();
                       // a2. 得到目标方法的参数

                       // b. 根据"add two int"经过queryLocalIInterface（）获取相应的IInterface对象（即Server建立的plus）的引用，经过该对象引用调用方法
                       int  result = this.queryLocalIInterface("add two int") .add( arg0,  arg1); 

                        // c. 将计算结果写入到reply
                        reply.writeInt(result); 

                        return true; 
                  }
           } 
      return super.onTransact(code, data, reply, flags); 
      // 2. 将结算结果返回 到Binder驱动
步骤3：Server进程 将目标方法的结果（即加法后的结果）返回给Client进程

  // 1. Binder驱动根据 代理对象 沿原路 将结果返回 并通知Client进程获取返回结果
  // 2. 经过代理对象 接收结果（以前被挂起的线程被唤醒）

    binderproxy.transact(Stub.ADD, data, reply, 0)；
    reply.readException();；
    result = reply.readInt()；
          }
}

若是用一个流程图来表示的话，栖流程以下：

那为何Android会重写进程的通讯机制，而不直接使用Linux提供的进程通讯呢，主要有如下几点好处。
高效：Binder数据拷贝只须要一次，而管道、消息队列、Socket都须要2次；经过驱动在内核空间拷贝数据，不须要额外的同步处理；
安全性高：Binder 机制为每一个进程分配了 UID/PID 来做为鉴别身份的标示，而且在 Binder 通讯时会根据 UID/PID 进行有效性检测；传统的进程通讯方式对于通讯双方的身份并无作出严格的验证。如，Socket通讯 ip地址是客户端手动填入，容易出现伪造
使用简单：采用Client/Server 架构，实现面向对象的调用方式，即在使用Binder时就和调用一个本地对象实例同样。

本文同步分享在博客“xiangzhihong8”（CSDN）。
若有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一块儿分享。

再谈Android Binder跨进程通讯原理