进程间通信（IPC Inter-Process Communication）

进程和线程

• 进程与线程时包含于被包含的关系
• 进程一般指为一个执行单元，在移动设备上代表着一个应用或者程序。
• 线程时CPU最小的调度单元，线程是有限的系统资源。
• 一个进程中可以有一个线程，那么就是UI线程，当一个进程中有大量的耗时任务在UI线程中执行，就会造成ANR。解决这个ANR就是将耗时的任务放到子线程中去执行。

IPC

• IPC不是Android独有的，任何一个操作系统都有自己的IPC机制。Android内核是基于Liunx的，但是IPC机制并不完全继承自Linux系统的。Android中最有特色的通信方式就是Binder了。
• IPC的使用场景是对于多进程来说的。

IPC的情况

• 在特殊情况下，某些模块需要运行在单独的进程中。
• 加大应用可使用的的内存，来创建多进程获得更多的内存使用。

Android中的多进程模式

开启多进程模式

• 为四大组件指定android:process=""属性，即可开启多进程的模式。
• 还有一种非常规的开启方式就是，通过JNI在native层fork一个新的进程。
• 不指定process属性，默认的进程名字是包名，android:process=":name"进程名字是包名+":name"，这种命名方式的进程是属于当前应用的私有进程，其他应用的组件不可以和它跑在同一个进程中。android:process="com.example.process.name"这个方式的命名是一种完整的命名方式，这种进程属于全局进程，其他应用通过ShareUID方式可以和它跑在同一个进程中。
• Android会为每一个应用分配一个UID，具有相同的UID才能共享数据。两个应用通过ShareUID跑在同一个进程中，是由条件的，不仅ShareUID相同，并且签名相同才可以。
• Android为每一个应用分配了一个独立的虚拟机，不同的虚拟机在内存分配上有不同的地址空间，这样在不同的虚拟机中访问同一个类的对象会产生多个副本。

多进程会造成如下几个问题

• 静态成员和单利模式会失效
• 线程同步机制失效：不在同一个内存了
• SharedPreference的可靠性下降：并发读写会出现问题的
• Application会启动多次：进程就是单独一个应用存在独立的虚拟机中，启动一个应用就会执行Applicaton一次。

IPC基础概念介绍

Serializable接口

• Java提供的一个空接口，可序列化和反序列化。
• 实现序列化，需要实现Serializable接口，在类中声明

private static final long serialVersionUID = 3423432423423432L;

• 对象进行序列化

//User implements Serializable
//序列化的过程
User user = new User("jack",0,true);
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("cache.txt"));
out.writeObject(user);
out.close();
//反序列化的过程
ObjectInputStream in = new ObjectInputStream(new FileInputStream("cache.txt"));
User mUser = (User)in.readerObject();
in.close();

//user与mUser的内容一样，但不是同一个对象。

• serialVersionUID

serialVersionUID是用来辅助序列化和反序列，已经序列化的的数据中serialVersionUID和当前类中的serialVersionUID一致，这样反序列化才能成功。

• serialVersionUID的机制

当序列化的时候会将当前类的serialVersionUID写进文件中，当但序列化的时候，会去检查文件中serialVersionUID的值是否和当前类中的一致，一致就认为可以正常的反序列化，不一致就说明当前类发生了变化，无法完成发序列化操作，会抛出异常。

• 静态成员变量属于当前类，不参与序列化。用transient关键字标记的成员变量不参与序列化。

Parcelable接口

• Android官方提供的，实现起来比较复杂，但是效率高，Serializable实现简单但是开销比较大，序列化与反序列化都是操作IO
• 代码实现

public class User implements Parcelable {
    public int userId;
    public String userName;
    public boolean isMale;

    public User(int userId, String userName, boolean isMale) {
        this.userId = userId;
        this.userName = userName;
        this.isMale = isMale;
    }

    protected User(Parcel in) {
        userId = in.readInt();
        userName = in.readString();
        isMale = in.readInt() != 0;
    }

    /**
     * 反序列化由CREATOR来实现
     */
    public static final Creator<User> CREATOR = new Creator<User>() {
        /**
         * 从序列化的数据中创建原始对象
         * @param in
         * @return
         */
        @Override
        public User createFromParcel(Parcel in) {
            return new User(in);
        }

        /**
         * 创建指定长度的原始对象长度
         * @param size
         * @return
         */
        @Override
        public User[] newArray(int size) {
            return new User[size];
        }
    };

    /**
     * 返回当前对象的描述 几乎所有情况返回0 如果含有文件描述符 返回1
     * @return
     */
    @Override
    public int describeContents() {
        return 0;
    }

    /**
     * 序列化的过程
     *
     * @param dest  parcel对象中封装了可序列化的数据,可以在Binder中自由传输
     * @param flags
     */
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(userId);
        dest.writeString(userName);
        dest.writeInt(isMale ? 1 : 0);
    }
}

Parcelable 与Serializable接口的比较

• Parcelable更好的用于内存序列化中
• Serializable更好的用于对象序列化到存储设备或者将对象序列化后通过网络传输

Binder

• Binder是Android中的一个类，实现了IBinder接口
• IPC角度说，Binder是Android中跨进程通信的一种方式。
• 从Framework角度说，Binder是ServiceManager链接各种Manager和ManagerService的桥梁。
• 应用层角度说 Binder是客户端和服务端进行通信的介质。
• Android开发中Binder主要用于Service中，普通的Service中的Binder不涉及进程间通信。

Binder的原理通过AIDL文件来分析

• Messenger的地层实现是AIDL，用AIDL来分析Binder的原理
• 继承IInterface接口
• 核心是内部类Stub和Stub的内部代理类Proxy
• Stub是继承了Binder，所以Stub本身也是一个Binder
• asInterface：用于将服务端的Binder对象转化成客户端所需的AIDL类型的对象。如果客户端和服务端在用一个进程中，会返回Stub对象。如果不在同一个进程中，会返回Stub.Proxy封装后的对象。
• onTransact：运行在服务端的Binder线程池中，当客户端发起跨进程请求的时候，远程请求会通过系统的底层封装后交给这个方法来处理，通过Code来判断是调用那个方法，从data中获取目标方法所需要的参数。当目标方法执行完毕后，向reply中写入返回值。
• Proxy # getBookList():创建输入输出型对象_data、_reply，和返回值结果，将方法的参数写入到_data中，调用transact()方法，发起RPC请求（远程过程调用），此时客户端的线程会被挂起，直到RPC过程结束返回结果，重新唤醒客户端线程。最后将RPC返回的结果写入到返回值结果中，返回返回值。
• 声明的常量：用来标识trasact过程中，客户端请求的是那个方法。

IPC通信方式

Bundle

文件共享

Messenger（信使）

• Messenger可以在不同的进程中传递Message对象，在Message中放入我们传递的数据，就可以进行数据的跨进程传递了。
• Messenger对AIDL做了封装，可以方便简单的进行进程间通信。
  服务端进程

在服务端创建一个Service来处理客户端的连接请求，同时创建一个Handler，并通过它来创建一个Messenger对象，然后在Service的onBind中返回这个Messenger对象底层Binder即可。

public class MyService extends Service {
    private static final String TAG = "MyService";

    @Override
    public IBinder onBind(Intent intent) {
        return mMessenger.getBinder();
    }


    static Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MyConstants.MSG_FROM_CLIENT:
                    //获取从客户端发来的消息
                    Log.d(TAG, "handleMessage: " + msg.getData().getString("msg"));
                    break;
            }
            super.handleMessage(msg);
        }
    };


    private Messenger mMessenger = new Messenger(mHandler);
}

客户端进程

• 绑定服务端的Service
• 绑定成功后获取到返回的IBinder对象，通过该对象创建一个Messenger对象。
• 构建Message对象，将数据放入到Bundle中，Message携带Bundle，通过创建好的Messenger对象将消息发送出去。

public class MainActivity extends AppCompatActivity {

    private Messenger mMMessenger;
    private Message mMMessage;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Intent intent = new Intent(this, MyService.class);
        //绑定服务
        bindService(intent, mServiceConnection, BIND_AUTO_CREATE);
    }

    private ServiceConnection mServiceConnection = new ServiceConnection() {

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //与服务成功绑定回调
            mMMessenger = new Messenger(service);
            mMMessage = Message.obtain(null, MyConstants.MSG_FROM_CLIENT);
            //通过Bundle传递数据
            Bundle data = new Bundle();
            data.putString("msg", "i am from client");
            //Message携带数据
            mMMessage.setData(data);

            try {
                //发送消息
                mMMessenger.send(mMMessage);
            } catch (RemoteException e) {
                e.printStackTrace();
            }


        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };
}

• Message中所支持的数据类型，Messenger也支持。
• Message中object字段在同一个进程中可以携带数据，在不同进程中传递数据该字段失效。也就是说序列化好的对象不能通过该字段进行跨进程传递数据。
• Bundle可以支持很多数据类型，这点可以替代Message的object字段

AIDL

服务端

客户端

AIDL文件

AIDL中支持的数据类型

• 基本数据类型。
• String和CharSequence。
• List：仅仅支持ArrayList 并且ArrayList中的每一个元素也能被AIDL支持。
• Map：支持HashMap，并且对应的key和value能被支持。
• Parcelable：所有实现了Parcelable接口的对象。
• AIDL：所有的AIDL接口本身可以AIDL的文件使用。
  注意的点
• AIDL文件中使用的自定义的Parcelable对象和AIDL对象必须显式的import进来。
• AIDL文件中使用的自定义Parcelable对象，必须新建一个同名的AIDL文件，并且声明它为parcelable类型。
• 除了基本数据类型，其他类型必须标上方向：in，out，inout
• 跟传统接口相比，AIDL文件就支持方法，不支持声明静态常量。
• 方便开发，建议把AIDL相关的类都放在同一个包中。

远程服务端Service的实现

public class BookManagerService extends Service {
    //装书的
    private CopyOnWriteArrayList<Book> mBookList = new CopyOnWriteArrayList<>();

    private RemoteCallbackList<IBookArrivedListener> mListenerList = new RemoteCallbackList<>();

    private AtomicBoolean mServiceIsDestroy = new AtomicBoolean(false);

    private IBinder mBookManager = new IBookManager.Stub() {

        @Override
        public void addBook(Book book) throws RemoteException {
            mBookList.add(book);

        }

        @Override
        public List<Book> getBookList() throws RemoteException {
            return mBookList;
        }

        @Override
        public void registerListener(IBookArrivedListener listener) throws RemoteException {
            mListenerList.register(listener);

        }

        @Override
        public void unregisterListener(IBookArrivedListener listener) throws RemoteException {
            mListenerList.unregister(listener);
        }
    };

    @Override
    public void onCreate() {
        super.onCreate();
        mBookList.add(new Book("Java", 1));
        mBookList.add(new Book("Android", 2));
        new Thread(new ServiceWorker()).start();
    }

    @Override
    public IBinder onBind(Intent intent) {
        //此处返回的IBinder对象，会在ServiceConnection绑定成功的方法中返回。根据IBinder对象，
        // 可以获取到客户端需要的AIDL类型的对象，
        //可以进行跨进程的调用方法。
        return mBookManager;
    }

    @Override
    public void onDestroy() {
        mServiceIsDestroy.set(true);
        super.onDestroy();
    }

    private void onBookIsArrived(Book book) throws RemoteException {
        mBookList.add(book);
        int count = mListenerList.beginBroadcast();
        for (int i = 0; i < count; i++) {
            IBookArrivedListener broadcastItem = mListenerList.getBroadcastItem(i);
            broadcastItem.onBookIsArrived(book);
        }

        mListenerList.finishBroadcast();

    }

    private class ServiceWorker implements Runnable {

        @Override
        public void run() {
            while (!mServiceIsDestroy.get()) {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                int bookId = mBookList.size() + 1;
                Book mNewBook = new Book("new book # " + bookId, bookId);
                try {
                    onBookIsArrived(mNewBook);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

客户端的实现

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    private IBookManager mRemoteBookManager;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Intent intent = new Intent(MainActivity.this, BookManagerService.class);
        bindService(intent, mServiceConnection, BIND_AUTO_CREATE);
    }

    private ServiceConnection mServiceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            // asInterface 作用是将服务端的Binder对象转化成客户端所需要的AIDI类型的对象
            IBookManager mBookManager = IBookManager.Stub.asInterface(service);
            mRemoteBookManager = mBookManager;
            try {
                List<Book> bookList = mBookManager.getBookList();
                Log.d(TAG, "list category =  " + bookList.getClass().getCanonicalName());
                Log.d(TAG, "onServiceConnected: " + bookList.toString());
                Book mNewBook = new Book("Python", 4);
                mBookManager.addBook(mNewBook);
                Log.d(TAG, "onServiceConnected: " + mBookManager.getBookList());
                mBookManager.registerListener(mIBookIsArrivedListener);

            } catch (RemoteException e) {
                e.printStackTrace();
            }


        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };

    private IBookIsArrivedListener mIBookIsArrivedListener = new IBookIsArrivedListener.Stub() {

        @Override
        public void onNewBookArrived(Book book) throws RemoteException {
            //获取到新到的书籍  onNewBookArrived是运行客户端在Binder的线程池中的，为了方便操作UI切换到UI线程中
            mUIHandler.obtainMessage(1, book).sendToTarget();
        }
    };


    @Override
    protected void onDestroy() {
        if (mRemoteBookManager != null && mRemoteBookManager.asBinder().isBinderAlive()) {
            try {
                Log.d(TAG, "unregister listener:" + mIBookIsArrivedListener);
                //Binder会把客户端传递过来的对象转成一个新的对象，所以在服务端是不会解除事件的监听。
                //对象是不能进行跨进程传递，对象的跨进程传递本质上反序列的过程，反序列得到的内容一致，但是不是一个对象了，是一个新的对象了。
                //这个时候就得用到RemoteCallbackList 专门用来删除跨进程listener的接口。
                //多进程传递对象会在服务端会产生不同的对象，但是这不同的对象 在RemoteCallbackList中对应的key是一致的 都是底层的Binder对象。
                mRemoteBookManager.unregisterListener(mIBookIsArrivedListener);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        unbindService(mServiceConnection);
        super.onDestroy();
    }

    private Handler mUIHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 1:
                    Log.d(TAG, "handleMessage: " + msg.obj);
                    break;
            }
            super.handleMessage(msg);
        }
    };
}

AIDL文件的实现

• Book.aidl

// My.aidl
package wanandroidqi.dashingqi.com.myaidlproject2.aidl;

// Declare any non-default types here with import statements

parcelable Book;

• IBookManager.aidl

// IBookManager.aidl
package wanandroidqi.dashingqi.com.myaidlproject2.aidl;

// Declare any non-default types here with import statements
import wanandroidqi.dashingqi.com.myaidlproject2.aidl.Book;
import wanandroidqi.dashingqi.com.myaidlproject2.aidl.IBookArrivedListener;

interface IBookManager {
    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    void addBook(in Book book);
    List<Book> getBookList();

    void registerListener(IBookArrivedListener listener);
    void unregisterListener(IBookArrivedListener listener);

}

• IBookArrivedListener.aidl

// IBookArrivedListener.aidl
package wanandroidqi.dashingqi.com.myaidlproject2.aidl;

// Declare any non-default types here with import statements
import wanandroidqi.dashingqi.com.myaidlproject2.aidl.Book;

interface IBookArrivedListener {
    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
   void onBookIsArrived(in Book book);
}

• 客户端调用服务端的方法，服务端的方法是运行在服务端的Binder线程池中，同时客户端的线程会被挂起，这时服务端的方法耗时，就会导致客户端长时间阻塞，如果客户端所在是UI线程，就会导致ANR。一般在将客端调用服务端是开启一个新线程。