Android跨进程通讯：图文详解 Binder机制 原理
前言
- 若是你接触过 跨进程通讯 （
IPC），那么你对Binder必定不陌生 - 虽然 网上有不少介绍
Binder的文章，但是存在一些问题：浅显的讨论Binder机制 或 一味讲解Binder源码、逻辑不清楚，最终致使的是读者们仍是没法造成一个完整的Binder概念 - 本文采用 清晰的图文讲解方式，按照 大角度 -> 小角度 去分析
Binder，即：- 先从 机制、模型的角度 去分析 整个
Binder跨进程通讯机制的模型 - 再 从源码实现角度，分析
Binder在Android中的具体实现
- 先从 机制、模型的角度 去分析 整个
从而全方位地介绍 Binder，但愿大家会喜欢。android
请尽可能在PC端而不要在移动端看，不然图片可能看不清。web
目录
1. Binder究竟是什么？
-
中文即 粘合剂，意思为粘合了两个不一样的进程缓存
-
网上有不少对
Binder的定义，但都说不清楚：Binder是跨进程通讯方式、它实现了IBinder接口，是链接ServiceManager的桥梁blabla，估计你们都看晕了，无法很好的理解安全 -
我认为：对于
Binder的定义，在不一样场景下其定义不一样微信
在本文的讲解中，按照 大角度 -> 小角度 去分析Binder，即：多线程
- 先从 机制、模型的角度 去分析 整个
Binder跨进程通讯机制的模型
其中，会详细分析模型组成中的
Binder驱动架构
- 再 从源码实现角度，分析
Binder在Android中的具体实现
从而全方位地介绍 Binder，但愿大家会喜欢。并发
2. 知识储备
在讲解Binder前，咱们先了解一些Linux的基础知识ide
2.1 进程空间划分
- 一个进程空间分为 用户空间 & 内核空间（
Kernel），即把进程内 用户 & 内核 隔离开来 - 两者区别：
- 进程间，用户空间的数据不可共享，因此用户空间 = 不可共享空间
- 进程间，内核空间的数据可共享，因此内核空间 = 可共享空间
全部进程共用1个内核空间svg
- 进程内 用户空间 & 内核空间 进行交互 需经过 系统调用，主要经过函数：
- copy_from_user（）：将用户空间的数据拷贝到内核空间
- copy_to_user（）：将内核空间的数据拷贝到用户空间
2.2 进程隔离 & 跨进程通讯（ IPC ）
-
进程隔离
为了保证 安全性 & 独立性，一个进程 不能直接操做或者访问另外一个进程，即Android的进程是相互独立、隔离的 -
跨进程通讯（
IPC）
即进程间需进行数据交互、通讯 -
跨进程通讯的基本原理
a. 而
Binder的做用则是：链接 两个进程，实现了mmap()系统调用，主要负责 建立数据接收的缓存空间 & 管理数据接收缓存
b. 注：传统的跨进程通讯需拷贝数据2次，但Binder机制只需1次，主要是使用到了内存映射，具体下面会详细说明
2.5 内存映射
具体请看文章：操做系统：图文详解 内存映射
3. Binder 跨进程通讯机制 模型
3.1 模型原理图
Binder 跨进程通讯机制 模型 基于 Client - Server 模式
3.2 模型组成角色说明
此处重点讲解 Binder驱动的做用 & 原理：
- 简介
- 跨进程通讯的核心原理
关于其核心原理：内存映射，具体请看文章：操做系统：图文详解 内存映射
3.3 模型原理步骤说明
3.4 额外说明
说明1：Client进程、Server进程 & Service Manager 进程之间的交互 都必须经过Binder驱动（使用 open 和 ioctl文件操做函数），而非直接交互
缘由：
Client进程、Server进程 &Service Manager进程属于进程空间的用户空间，不可进行进程间交互Binder驱动 属于 进程空间的 内核空间，可进行进程间 & 进程内交互
因此，原理图可表示为如下：
虚线表示并不是直接交互
说明2： Binder驱动 & Service Manager进程 属于 Android基础架构（即系统已经实现好了）；而Client 进程 和 Server 进程 属于Android应用层（须要开发者本身实现）
因此，在进行跨进程通讯时，开发者只需自定义Client & Server 进程 并 显式使用上述3个步骤，最终借助 Android的基本架构功能就可完成进程间通讯
说明3：Binder请求的线程管理
Server进程会建立不少线程来处理Binder请求Binder模型的线程管理 采用Binder驱动的线程池，并由Binder驱动自身进行管理
而不是由
Server进程来管理的
- 一个进程的
Binder线程数默认最大是16，超过的请求会被阻塞等待空闲的Binder线程。
因此，在进程间通讯时处理并发问题时，如使用
ContentProvider时，它的CRUD（建立、检索、更新和删除）方法只能同时有16个线程同时工做
- 至此，我相信你们对
Binder跨进程通讯机制 模型 已经有了一个很是清晰的定性认识 - 下面，我将经过一个实例，分析
Binder跨进程通讯机制 模型在Android中的具体代码实现方式
即分析 上述步骤在
Android中具体是用代码如何实现的
4. Binder机制 在Android中的具体实现原理
Binder机制在Android中的实现主要依靠Binder类，其实现了IBinder接口
下面会详细说明
- 实例说明：
Client进程 须要调用Server进程的加法函数（将整数a和b相加）
即：
Client进程 须要传两个整数给Server进程Server进程 须要把相加后的结果 返回给Client进程
- 具体步骤
下面，我会根据Binder跨进程通讯机制 模型的步骤进行分析
步骤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信息- 具体代码实现过程以下：
此时，Client进程与 Server进程已经创建了链接
步骤3：使用服务
Client进程 根据获取到的 Service信息（Binder代理对象），经过Binder驱动 创建与 该Service所在Server进程通讯的链路，并开始使用服务
-
过程描述
Client进程 将参数（整数a和b）发送到Server进程Server进程 根据Client进程要求调用 目标方法（即加法函数）Server进程 将目标方法的结果（即加法后的结果）返回给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()；
}
}
- 总结
下面，我用一个原理图 & 流程图来总结步骤3的内容
5. 优势
对比 Linux （Android基于Linux）上的其余进程通讯方式（管道、消息队列、共享内存、
信号量、Socket），Binder 机制的优势有：
6. 总结
- 本文主要详细讲解 跨进程通讯模型
Binder机制 ，总结以下：
特别地，对于从模型结构组成的Binder驱动来讲：
- 整个
Binder模型的原理步骤 & 源码分析
- 下面我将继续对
Android中的知识进行讲解 ，感兴趣的同窗能够继续关注carson_ho的微信公众号