IPC（Inter-Process Communication，跨进程通信）是指两个进程之间数据交换的过程，因此我们首先必须了解什么是进程，什么是线程。

进程：进程是正在运行的程序的实例，与程序相比，它更强调动态的概念，与线程相比，进程是线程的容器，一个进程可以包含多个线程但至少包含一个线程。进程是任务调度的基本单位，是系统资源的分配单位。

线程：线程是进程中的一条执行路径，它只能隶属于某一个进程，在支持多线程的操作系统或程序设计语言中（如java），线程是任务调度的单位，但它不是系统资源分配的单位，线程完全继承父进程占有的资源，但它执行时，也有属于自己的运行现场，如PC寄存器的值，栈空间等。

关于进程与线程内存资源方面的知识请参看我的博文：。

IPC机制不是安卓独有的，任何一个操作系统都需要IPC机制，如linux中可以通过命名管道，共享主存，信号量，Socket，消息队列等方式来呢实现IPC机制，安卓虽然是基于linux内核的，但是安卓中的IPC机制与linux不完全相同，如Binder机制就是安卓的IPC中的一大特色，这种IPC机制在linux中是不存在的。本博客将详细讲解安卓中的Binder机制。

在安卓开发中Binder主要用在Service中，包括AIDL与Messenger，而Messenger的底层仍然是AIDL，关于这些内容，读者可以参看我的博客：。所以本博客将以AIDL为例详细讲解Binder的IPC原理。

首先创建一个AIDL的java包，在该包中创建三个文件Book.java,Book.aidl和IBookManager.aidl代码如下：

public class Book implements Parcelable {  //Book.java    public int bookId;    public String bookName;    public Book() {    }    public Book(int bookId, String bookName) {        this.bookId = bookId;        this.bookName = bookName;    }    public int describeContents() {        return 0;    }    public void writeToParcel(Parcel out, int flags) {        out.writeInt(bookId);        out.writeString(bookName);    }    public static final Parcelable.Creator
    
      CREATOR = new Parcelable.Creator
     
      () {        public Book createFromParcel(Parcel in) {            return new Book(in);        }        public Book[] newArray(int size) {            return new Book[size];        }    };    private Book(Parcel in) {        bookId = in.readInt();        bookName = in.readString();    }    @Override    public String toString() {        return String.format("[bookId:%s, bookName:%s]", bookId, bookName);    }}parcelable Book;//Book.aidlinterface IBookManager {  //IBookManager.aidl     List
      
        getBookList();     void addBook(in Book book);}
      
     
    

其中Book.java是一个表示图书信息的java类，它实现了Parcelable接口，Book.aidl是Book类在AIDL中的声明，IBookManager.aidl是我们定义的一个接口，注意尽管Book类与IBookManager类位于同一个包中，但是在IBookManager.aidl文件中仍需要导入Book类，这是aidl文件与普通java的class文件的不同之处。

当我们定义好上述文件后Eclipse会自动为我们在工程的gen目录下生成一个与IBookManager.aidl文件相对应的java类IBookManager.java，我们来看一下其源码：

public interface IBookManager extends android.os.IInterface{/** Local-side IPC implementation stub class. */public static abstract class Stub extends android.os.Binder implements com.test.aidl.IBookManager{private static final java.lang.String DESCRIPTOR = "com.test.aidl.IBookManager";/** Construct the stub at attach it to the interface. */public Stub(){this.attachInterface(this, DESCRIPTOR);}/** * Cast an IBinder object into an com.test.aidl.IBookManager interface, * generating a proxy if needed. */public static com.test.aidl.IBookManager asInterface(android.os.IBinder obj){   if ((obj==null)) {    return null;    }	android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);	  if (((iin!=null)&&(iin instanceof com.test.aidl.IBookManager))) {	  return ((com.test.aidl.IBookManager)iin);	}        return new com.test.aidl.IBookManager.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_getBookList:     { 	data.enforceInterface(DESCRIPTOR);	java.util.List
    
      _result = this.getBookList();	reply.writeNoException();	reply.writeTypedList(_result);	return true;      }      case TRANSACTION_addBook:     {	data.enforceInterface(DESCRIPTOR);	com.test.aidl.Book _arg0;	if ((0!=data.readInt())) {		_arg0 = com.test.aidl.Book.CREATOR.createFromParcel(data);	}	else {	_arg0 = null;	}	this.addBook(_arg0);	reply.writeNoException();	return true;	}      }	return super.onTransact(code, data, reply, flags);}private static class Proxy implements com.test.aidl.IBookManager{      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;	}	@Override    public java.util.List
     
       getBookList() throws android.os.RemoteException     {	android.os.Parcel _data = android.os.Parcel.obtain();	android.os.Parcel _reply = android.os.Parcel.obtain();	java.util.List
      
        _result;	try {		_data.writeInterfaceToken(DESCRIPTOR);		mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);		_reply.readException();		_result = _reply.createTypedArrayList(com.test.aidl.Book.CREATOR);	}	finally {	_reply.recycle();	_data.recycle();	}	return _result;     }@Override public void addBook(com.test.aidl.Book book) throws android.os.RemoteException{   android.os.Parcel _data = android.os.Parcel.obtain();   android.os.Parcel _reply = android.os.Parcel.obtain();  try {   _data.writeInterfaceToken(DESCRIPTOR);   if ((book!=null)) {     _data.writeInt(1);      book.writeToParcel(_data, 0);      }   else {     _data.writeInt(0);   }     mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);     _reply.readException();  }     finally {    _reply.recycle();     _data.recycle();     }   }}	static final int TRANSACTION_getBookList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);	static final int TRANSACTION_addBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);	public java.util.List
       
         getBookList() throws android.os.RemoteException;	public void addBook(com.test.aidl.Book book) throws android.os.RemoteException;}
       
      
     
    

可以看到系统为我们自动创建的IBookManager文件仍然是一个接口，它继承自android.os.IInterface。在其内部创建了一个抽象的静态类Stub，它继承自Binder类同时实现了IBookManager接口（但未实现该接口中的方法，因为该接口中的方法是我们在创建一个Service时在其内部创建Binder类时实现的，因此该Stub仍然属于一个抽象类）。

我们首先来梳理一下IBookManager接口的内容，可以看到，首先包含两个方法的声明getBookList和addBook,显然这两个方法是我们在IBookManager.aidl文件中声明的两个方法，另外它还定义了两个整型的id用于标识这两个方法，这两个id在其内部代理类Proxy的方法的transact过程中用于判断客户端请求的是哪一个方法。另外还包含一个内部类Stub，该Stub是一个Binder类，在这个Stub类中定义了一个内部类Proxy。

下面介绍一下上述代码中的一些重要方法：

public static com.test.aidl.IBookManager asInterface(android.os.IBinder obj){   if ((obj==null)) {    return null;    }	android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);	  if (((iin!=null)&&(iin instanceof com.test.aidl.IBookManager))) {//此时表示客户端与服务端位于同一个进程中，直接返回IInterface对象	  return ((com.test.aidl.IBookManager)iin);	}        return new com.test.aidl.IBookManager.Stub.Proxy(obj);//此时表示客户端与服务端不在同一个进程中，此时返回代理类Proxy对象 }

asInterface正是我们在bindServide的组件中使用ServiceConnection时首先要使用的一个方法，可以看到在方法中首先通过obj.queryLocalInterface(DESCRIPTOR)根据传入的参数获取IInterface对象，然后判断该对象是否为IBookManager类，若是则直接返回该对象，此时表示客户端与服务端位于同一个进程中，即绑定的是本地服务，即在ServiceConnection的onServiceConnected中我们是这么调用的Binder对象

public void onServiceConnected(ComponentName name, IBinder service) {                myBinder = (MyService.MyBinder) service;   //绑定的是本地服务             myBinder.doSomething();            }

否则返回IBookManager类的内部代理对象IBookManager.Stub.Proxy(obj)，也就意味着客户端与服务端位于不同的进程中，此时客户端调用的方法将会是Proxy代理类中定义的方法，而不是直接调用的在Service中实现的IBookManager.aidl文件中的方法。即绑定的是远程服务，即在ServiceConnection的onServiceConnected中我们是这么调用的Binder对象

public void onServiceConnected(ComponentName name, IBinder service) {                myBinder = MyAIDL.Stub.asInterface(service)  //绑定的是远程服务            myBinder.doSomething();            }

通过上面的分析可知，当绑定的是远程服务时，当在客户端调用addBook将会调用代理类中的 addBook方法，因此我们接下来看一下Proxy#addBook

@Override public void addBook(com.test.aidl.Book book) throws android.os.RemoteException{   android.os.Parcel _data = android.os.Parcel.obtain();   android.os.Parcel _reply = android.os.Parcel.obtain();  try {   _data.writeInterfaceToken(DESCRIPTOR);   if ((book!=null)) {     _data.writeInt(1);      book.writeToParcel(_data, 0);      }   else {     _data.writeInt(0);   }     mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);     _reply.readException();  }     finally {    _reply.recycle();     _data.recycle();     } }

可以看到在该方法中首先创建了一个输入型参数Parce对象_data与输出型Parcel对象_reply，然后向该输入型参数Parce对象_data中写入一些数据，然后调用了mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);语句，当执行该语句时，即表示客户端发起RPC（远程过程调用）请求，此时当前线程会被挂起，直至RPC过程返回后，当前线程继续执行。注意该mRemote对象即为在创建该Proxy对象时传入的Binder对象，即mRemote是一个Binder对象，我们看一下Binder中的transact函数，代码如下：

/**     * Default implementation rewinds the parcels and calls onTransact.  On     * the remote side, transact calls into the binder to do the IPC.     */    public final boolean transact(int code, Parcel data, Parcel reply,            int flags) throws RemoteException {        if (false) Log.v("Binder", "Transact: " + code + " to " + this);        if (data != null) {            data.setDataPosition(0);        }        boolean r = onTransact(code, data, reply, flags);        if (reply != null) {            reply.setDataPosition(0);        }        return r;    }

可以看到transact函数被final修饰，即该函数是不允许被继承重写的，在该函数中最重要的一个语句： boolean r = onTransact(code, data, reply, flags);即在transact函数中调用了onTransact函数，而onTransact函数一般是要求被重写的，而重写的过程是根据我们自己定义的aidl文件IDE自动帮我们完成的，如上面所示的根据IBookManager.aidl文件自动生成IBookManager.java文件，在这个IBookManager.java文件中onTransact函数被重写。

这个onTransact函数是Binder机制运行的关键，该函数运行在服务端的Binder线程池中，当客户端发起跨进程请求时，即调用transact函数时，远程请求的数据会通过系统底层交给该函数来执行，该函数的完整签名为： public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags)，服务端通过code可以确定客户端调用的是那个方法，然后从data中取出目标方法所带的参数（如果目标方法带参数的话），然后执行目标方法，当目标方法执行完毕后，就向reply中写入返回值（如果目标方法存在返回值的话），需要注意的是如果该函数返回false，则客户端的请求会失败，利用该特性可以做权限验证，因为我们也不希望任意一个进程都可以随意访问我们的服务。

通过上述的分析相信读者对Binder的运行机制的整个过程已经非常熟悉了，至于系统底层的Binder是如何传输数据的这个不重要，也不需要我们去理解，我们只需要知道Binder的运行机制的整个过程，下面用图示的方式来讲上述过程表示出来。注意下面图示仅仅表示绑定远程服务的过程，因为绑定本地服务不涉及IPC机制。如下：

对上述图示还是稍作解释，首先在客户端Client的ServiceConnection的onServiceConnected(ComponentName name, IBinder service) 方法中我们是通过   myBinder = MyAIDL.Stub.asInterface(service)语句将service转换为Binder对象，即调用的是asInterface方法而不是使用(MyService.MyBinder) service的类型转换的方式，则表示我们要获取的是远程服务而不是本地服务，那么接下来 myBinder调用的addBook(book);这个方法将会在其内部调用Binder的transact方法用来发起RPC请求，此时客户端Client被挂起，Binder的transact方法是一个final方法，不允许被修改，在该方法中调用了onTransact方法，该方法运行在服务端的Binder线程池中，该方法是整个Binder机制运行的关键，在该方法中完成IPC数据的读取与写入，该方法返回值将写入_reply参数中，然后RPC过程结束，返回数据给客户端，客户端Client被唤醒。

另外因为服务端的Binder方法是运行在Binder线程池中的，所以Binder中的方法不管是否耗时都应该采用同步的方式去实现，因为它已经运行在一个线程中。