Android开发面试被问Binder还不会，收藏这一篇就够了（附图解）(1)

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注Android）

正文

Binder的调用流程大致如下，native层BpBinder的Bp指的是Binder proxy，

可见，需要经过如下调用才能完成一次通信：

1. 请求：客户端Java层->客户端native层->Binder驱动层->服务端native层->服务端Java层

2. 响应：服务端Java层->服务端native层->Binder驱动层->客户端native层->客户端Java层

即Binder驱动层充当着一个中转站的作用，有点像网络分层模型。

客户端与驱动交互

先来看客户端与驱动的交互。因为是跨进程调用（指定了:remote），示例里onServiceConnected回调回来的service对象是个BinderProxy代理实例（不跨进程的话会发生远程转本地，后面讲），我们以service.transact(1, data, reply, 0)这行调用作为入口跟进。

BinderProxy类写在Binder类文件里面：

//BinderProxy.java

public boolean transact(int code, Parcel data, Parcel reply, int flags){

//调用了native方法

return transactNative(code, data, reply, flags);

}

这个native方法在android_util_Binder.cpp里注册，

//android_util_Binder.cpp

//JNI注册

static const JNINativeMethod gBinderProxyMethods[] = {

{ “transactNative”,

“(ILandroid/os/Parcel;Landroid/os/Parcel;I)Z”,

(void*)android_os_BinderProxy_transact},

};

//native方法具体实现

static jboolean android_os_BinderProxy_transact(JNIEnv* env, jobject obj,

jint code, jobject dataObj, jobject replyObj, jint flags){

//转成native层的Parcel

Parcel* data = parcelForJavaObject(env, dataObj);

Parcel* reply = parcelForJavaObject(env, replyObj);

//拿到native层的句柄BpBinder

IBinder* target = (IBinder*)

env->GetLongField(obj, gBinderProxyOffsets.mObject);

//调用BpBinder的transact

status_t err = target->transact(code, *data, reply, flags);

}

继续跟BpBinder.cpp，

//BpBinder.cpp

status_t BpBinder::transact(…){

//交给线程单例处理，驱动会根据mHandle值来找到对应的binder句柄

status_t status = IPCThreadState::self()->transact(

mHandle, code, data, reply, flags);

}

IPCThreadState是一个线程单例，负责与binder驱动进行具体的指令通信，跟进IPCThreadState.cpp，

//IPCThreadState.cpp

status_t IPCThreadState::transact(…){

//将数据写入mOut，见1.1

err = writeTransactionData(BC_TRANSACTION, flags, handle, code, data, NULL);

//…先忽略one way异步调用的代码，只看有返回值的同步调用

//跟binder驱动交互，传入reply接收返回数据，见1.2

err = waitForResponse(reply);

}

//1.1 将数据写入mOut

status_t IPCThreadState::writeTransactionData(…)

{

binder_transaction_data tr;

//…打包各种数据（data size、buffer、offsets）

tr.sender_euid = 0;

//将BC_TRANSACTION指令写入mOut

mOut.writeInt32(cmd);

//将打包好的binder_transaction_data写入mOut

mOut.write(&tr, sizeof(tr));

}

//1.2 跟binder驱动交互，传入reply接收返回数据

status_t IPCThreadState::waitForResponse(…){

//这个循环很重要，客户端就是在这里休眠等待服务端返回结果的

while (1) {

//跟驱动进行数据交互，往驱动写mOut，从驱动读mIn，见1.3

talkWithDriver();

//读取驱动回复的指令

cmd = (uint32_t)mIn.readInt32();

switch (cmd) {

case BR_TRANSACTION_COMPLETE:

//表示驱动已经收到客户端的transact请求

//如果是one way异步调用，到这就可以结束了

if (!reply && !acquireResult) goto finish;

break;

case BR_REPLY:

//表示客户端收到服务端的返回结果

binder_transaction_data tr;

//把服务端的数据读出来，打包进tr

err = mIn.read(&tr, sizeof(tr));

//再把tr的数据透传进reply

reply->ipcSetDataReference(…);

//结束

goto finish;

}

}

}

//1.3 跟驱动进行数据交互，往驱动写mOut，从驱动读mIn

status_t IPCThreadState::talkWithDriver(bool doReceive){

binder_write_read bwr;

//指定写数据大小和写缓冲区

bwr.write_size = outAvail;

bwr.write_buffer = (uintptr_t)mOut.data();

//指定读数据大小和读缓冲区

if (doReceive && needRead) {

bwr.read_size = mIn.dataCapacity();

bwr.read_buffer = (uintptr_t)mIn.data();

} else {

bwr.read_size = 0;

bwr.read_buffer = 0;

}

//ioctl的调用进入了binder驱动层的binder_ioctl

ioctl(mProcess->mDriverFD, BINDER_WRITE_READ, &bwr);

if (bwr.write_consumed > 0) {

//数据已经写入驱动，从mOut移除

if (bwr.write_consumed < mOut.dataSize())

mOut.remove(0, bwr.write_consumed);

else

mOut.setDataSize(0);

}

if (bwr.read_consumed > 0) {

//从驱动读出数据存入mIn

mIn.setDataSize(bwr.read_consumed);

mIn.setDataPosition(0);

}

}

ioctl的调用进入了binder驱动层的binder_ioctl，驱动层的代码先不跟。

服务端与驱动交互

从「一图摸清Android应用进程的启动」一文可知，服务端创建了一个线程注册进binder驱动，即binder线程，在ProcessState.cpp，

//ProcessState.cpp

virtual bool threadLoop()

{ //把binder线程注册进binder驱动程序的线程池中

IPCThreadState::self()->joinThreadPool(mIsMain);

return false;

}

跟进IPCThreadState.cpp，

//IPCThreadState.cpp

void IPCThreadState::joinThreadPool(bool isMain){

//向binder驱动写数据，表示当前线程需要注册进binder驱动

mOut.writeInt32(isMain ? BC_ENTER_LOOPER : BC_REGISTER_LOOPER);

status_t result;

do {

//进入死循环，等待指令的到来，见1.1

result = getAndExecuteCommand();

} while (result != -ECONNREFUSED && result != -EBADF);

//向binder驱动写数据（退出循环，线程结束）

mOut.writeInt32(BC_EXIT_LOOPER);

}

//1.1 等待指令的到来

status_t IPCThreadState::getAndExecuteCommand(){

//跟驱动进行数据交互，驱动会把指令写进mIn

talkWithDriver();

//从mIn读出指令

cmd = mIn.readInt32();

//执行指令，见1.2

result = executeCommand(cmd);

return result;

}

//1.2 执行指令

status_t IPCThreadState::executeCommand(int32_t cmd){

//客户端发请求到驱动，驱动转发到服务端

switch ((uint32_t)cmd) {

case BR_TRANSACTION:{

//服务端收到BR_TRANSACTION指令

binder_transaction_data tr;

//读出客户端请求的参数

result = mIn.read(&tr, sizeof(tr));

//准备数据，向上传给Java层

Parcel buffer; Parcel reply;

buffer.ipcSetDataReference(…);

//cookie保存的是binder实体，对应服务端的native层对象就是BBinder

reinterpret_cast<BBinder*>(tr.cookie)->transact(tr.code, buffer,

&reply, tr.flags);

//服务端向驱动写返回值，让驱动转发给客户端

sendReply(reply, 0);

}

}

}

//1.3 服务端向驱动写返回值，让驱动转发给客户端

status_t IPCThreadState::sendReply(const Parcel& reply, uint32_t flags){

err = writeTransactionData(BC_REPLY, flags, -1, 0, reply, &statusBuffer);

//服务端返回结果给客户端就行，不用等待客户端，所以传NULL

return waitForResponse(NULL, NULL);

}

然后看下BBinder的transact是怎么向上传递到Java层的，在Binder.cpp中，

//Binder.cpp

status_t BBinder::transact(uint32_t code, const Parcel& data,

Parcel* reply, uint32_t flags){

switch (code) {

//ping指令用来判断连通性，即binder句柄是否还活着

case PING_TRANSACTION:

reply->writeInt32(pingBinder());

break;

default:

//看这，通过JNI调用到Java层的execTransact，见1.1

err = onTransact(code, data, reply, flags);

break;

}

return err;

}

//android_util_Binder.cpp

//1.1 通过JNI调用到Java层的execTransact

virtual status_t onTransact(…){

JNIEnv* env = javavm_to_jnienv(mVM);

jboolean res = env->CallBooleanMethod(mObject, gBinderOffsets.mExecTransact, …);

}

回到Java层，execTransact如下：

//android.os.Binder.java

private boolean execTransact(…) {

res = onTransact(code, data, reply, flags);

}

至此就回调到了示例代码中服务端MyBinder的onTransact了，我们在示例中处理请求参数data和返回值reply，最后由native层的sendReply(reply, 0)真正向驱动写返回值，让驱动转发给客户端。

将调用代码和流程图结合起来：

然后是指令交互图（非one way模式）：

binder同步调用等到服务端的BR_REPLY指令后就真正结束，服务端则继续循环，等待下一次请求。

总结

---

本文主要介绍了Binder的背景和调用流程，将留下3个疑问继续探讨。

1. binder句柄是怎么传输和管理的（binder驱动和ServiceManager进程）

2. binder句柄的远程转本地

3. one way异步模式和他的串行调用（async_todo）、同步模式的并行调用

系列文章：

• 图解 | Android系统的启动

• 图解 | 一图摸清Android系统服务

• 图解 | 一图摸清Android应用进程的启动

细节补充

---

Binder为什么高效

Linux用户空间是无法直接读写磁盘的，系统所有的资源管理（读写磁盘文件、分配回收内存、从网络接口读写数据）都是在内核空间完成的，用户空间需要通过系统调用让内核空间完成这些功能。

传统IPC传输数据：发送进程需要copy_from_user从用户到内核，接收进程再copy_to_uer从内核到用户，两次拷贝。

而Binder传输数据：用mmap将binder内核空间的虚拟内存和用户空间的虚拟内存映射到同一块物理内存。copy_from_user将数据从发送进程的用户空间拷贝到接收进程的内核空间（一次拷贝），接收进程通过映射关系能直接在用户空间读取内核空间的数据。

（图片来源：「写给Android应用工程师的Binder原理剖析」）

Binder为什么不用shm

shm通常需要结合其他跨进程方式如信号量来同步信息，使用没有mmap方便。

提问

---

总结

作为一名从事Android的开发者，很多人最近都在和我吐槽Android是不是快要凉了？而在我看来这正是市场成熟的表现，所有的市场都是温水煮青蛙，永远会淘汰掉不愿意学习改变，安于现状的那批人，希望所有的人能在大浪淘沙中留下来，因为对于市场的逐渐成熟，平凡并不是我们唯一的答案！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注Android）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

( )Binder为什么不用shm

shm通常需要结合其他跨进程方式如信号量来同步信息，使用没有mmap方便。

提问

---

总结

作为一名从事Android的开发者，很多人最近都在和我吐槽Android是不是快要凉了？而在我看来这正是市场成熟的表现，所有的市场都是温水煮青蛙，永远会淘汰掉不愿意学习改变，安于现状的那批人，希望所有的人能在大浪淘沙中留下来，因为对于市场的逐渐成熟，平凡并不是我们唯一的答案！

[外链图片转存中…(img-1Zsz9xDV-1713451558639)]
[外链图片转存中…(img-qN5N0pRf-1713451558639)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注Android）
[外链图片转存中…(img-x31dPg4l-1713451558640)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！