目录

1. Binder到底是什么？

2. 知识储备

2.1 进程空间划分

2.2 进程隔离 & 跨进程通信（ IPC ）

2.3 内存映射

2.3.1 作用

2.3.2 实现过程

2.3.3 特点

2.3.4 应用场景

2.3.5 实例讲解

① 文件读 / 写操作

② 跨进程通信

3. Binder 跨进程通信机制 模型

3.1 模型原理图

3.2 模型组成角色说明

3.3 模型原理步骤说明

3.4 额外说明

4. Binder机制 在Android中的具体实现原理

步骤1：注册服务

步骤2：获取服务

步骤3：使用服务

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

步骤2：Server进程根据Client进要求 调用 目标方法（即加法函数）

步骤3：Server进程 将目标方法的结果（即加法后的结果）返回给Client进程

5. 优点

---

1. Binder到底是什么？

网上有很多对Binder的定义：Binder是跨进程通信方式、它实现了IBinder接口，是连接 ServiceManager的桥

我认为：对于Binder的定义，在不同场景下其定义不同

在本文的讲解中，按照 大角度 -> 小角度 去分析Binder，即：

先从机制、模型的角度去分析整个Binder跨进程通信机制的模型，其中，会详细分析模型组成中的 Binder驱动

再从源码实现角度，分析 Binder在 Android中的具体实现，从而全方位地介绍 Binder。

2. 知识储备

在讲解Binder前，我们先了解一些Linux的基础知识

2.1 进程空间划分

一个进程空间分为 用户空间 & 内核空间（Kernel），即把进程内 用户 & 内核 隔离开来

二者区别：

1. 进程间，用户空间的数据不可共享，所以用户空间 = 不可共享空间
2. 进程间，内核空间的数据可共享，所以内核空间 = 可共享空间

所有进程共用1个内核空间

进程内 用户空间 & 内核空间 进行交互 需通过 系统调用，主要通过函数：

1. copy_from_user（）：将用户空间的数据拷贝到内核空间
2. copy_to_user（）：将内核空间的数据拷贝到用户空间

2.2 进程隔离 & 跨进程通信（ IPC ）

• 进程隔离
  为了保证 安全性 & 独立性，一个进程 不能直接操作或者访问另一个进程，即Android的进程是相互独立、隔离的
• 跨进程通信（ IPC ）
  即进程间需进行数据交互、通信
• 跨进程通信的基本原理

a. 而Binder的作用则是：连接 两个进程，实现了mmap()系统调用，主要负责 创建数据接收的缓存空间 & 管理数据接收缓存
b. 注：传统的跨进程通信需拷贝数据2次，但Binder机制只需1次，主要是使用到了内存映射，具体下面会详细说明

2.3 内存映射

• 内存映射 在 Linux操作系统中非常重要，因为其涉及到高效的跨进程通信 & 文件操作

关联进程中的1个虚拟内存区域 & 1个磁盘上的对象，使得二者存在映射关系

1. 上述的映射过程 = 初始化该虚拟内存区域
2. 虚拟内存区域被初始化后，就会在交换空间中换你来还去
3. 被映射的对象称为：共享对象（普通文件 / 匿名文件）

2.3.1 作用

若存在上述映射关系，则具备以下特征

• 在多个进程的虚拟内存区域 已和同1个共享对象 建立映射关系的前提下
• 若 其中1个进程对该虚拟区域进行写操作
• 那么，对于 也把该共享对象映射到其自身虚拟内存区域的进程 也是可见的

示意图如下

1. 假设进程1、2的虚拟内存区域同时映射到同1个共享对象；
2. 当进程1对其虚拟内存区域进行写操作时，也会映射到进程2中的虚拟内存区域

 

2.3.2 实现过程

• 内存映射的实现过程主要是通过Linux系统下的系统调用函数：mmap（）
• 该函数的作用 = 创建虚拟内存区域 + 与共享对象建立映射关系
• 其函数原型、具体使用 & 内部流程 如下

/**
  * 函数原型
  */
void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);

/**
  * 具体使用（用户进程调用mmap（））
  * 下述代码即常见了一片大小 = MAP_SIZE的接收缓存区 & 关联到共享对象中（即建立映射）
  */
  mmap(NULL, MAP_SIZE, PROT_READ, MAP_PRIVATE, fd, 0);

/**
  * 内部原理
  * 步骤1：创建虚拟内存区域
  * 步骤2：实现地址映射关系，即：进程的虚拟地址空间 ->> 共享对象
  * 注： 
  *    a. 此时，该虚拟地址并没有任何数据关联到文件中，仅仅只是建立映射关系
  *    b. 当其中1个进程对虚拟内存写入数据时，则真正实现了数据的可见
  */

2.3.3 特点

• 提高数据的读、写 & 传输的时间性能

1. 1. 减少了数据拷贝次数
   2. 用户空间 & 内核空间的高效交互（通过映射的区域 直接交互）
   3. 用内存读写 代替 I/O读写

• 提高内存利用率：通过虚拟内存 & 共享对象

2.3.4 应用场景

在Linux系统下，根据内存映射的本质原理 & 特点，其应用场景在于：

1. 实现内存共享：如 跨进程通信
2. 提高数据读 / 写效率 ：如 文件读 / 写操作

2.3.5 实例讲解

下面，我将详细讲解 内存映射应用在跨进程通信 & 文件操作的实例

① 文件读 / 写操作

• 传统的Linux系统文件操作流程如下

• 使用了内存映射的 文件读 / 写 操作

从上面可看出：使用了内存映射的文件读/写 操作方式效率更加高、性能最好！

② 跨进程通信

• 传统的跨进程通信

• 使用了内存映射的 跨进程通信

从上面可看出：使用了内存映射的跨进程通信 效率最高、性能最好！

3. Binder 跨进程通信机制模型

3.1 模型原理图

Binder 跨进程通信机制 模型 基于 Client - Server 模式

3.2 模型组成角色说明

此处重点讲解 Binder驱动的作用 & 原理：

• 简介

• 跨进程通信的核心原理

3.3 模型原理步骤说明

3.4 额外说明

说明1：Client进程、Server进程 & Service Manager 进程之间的交互 都必须通过Binder驱动（使用 open 和 ioctl文件操作函数），而非直接交互

原因：

1. Client进程、Server进程 & Service Manager进程属于进程空间的用户空间，不可进行进程间交互
2. 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相加）

即：

1. Client进程 需要传两个整数给 Server进程
2. Server进程 需要把相加后的结果 返回给Client进程

• 具体步骤
  下面，我会根据Binder 跨进程通信机制 模型的步骤进行分析

步骤1：注册服务

• 过程描述
  Server进程 通过Binder驱动 向 Service Manager进程 注册服务
• 代码实现
  Server进程 创建 一个 Binder 对象

1. Binder 实体是 Server进程 在 Binder 驱动中的存在形式
2. 该对象保存 Server 和 ServiceManager 的信息（保存在内核空间中）
3. 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进程通信的链路，并开始使用服务

• 过程描述

1. 1. Client进程 将参数（整数a和b）发送到Server进程
   2. Server进程 根据Client进程要求调用 目标方法（即加法函数）
   3. 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 机制的优点有：

特别地，对于从模型结构组成的Binder驱动来说：

• 整个Binder模型的原理步骤 & 源码分析

该博主相关文章写的都很好，非常推荐阅读，原文链接：

Android跨进程通信：图文详解 Binder机制 原理_android binder机制_Carson带你学Android的博客-CSDN博客

操作系统：图文详解 内存映射 - 简书