Android进程框架：进程的创建、启动与调度流程

Zygote进程孵化出的第一个应用进程是Launcher进程（桌面），它还会孵化出Browser进程（浏览器）、Phone进程（电话）等。我们每个创建的应用都是一个单独的进程。

通过上述流程的分析，想必读者已经对Android的整个进程模型有了大致的理解。作为一个应用开发者我们往往更为关注Framework层和App层里进程的创建与管理相关原理，我们来 一一分析。

一 进程的创建与启动流程

在正式介绍进程之前，我们来思考一个问题，何为进程，进程的本质是什么？🤔

我们知道，代码是静态的，有代码和资源组成的系统要想运行起来就需要一种动态的存在，进程就是程序的动态执行过程。何为进程？ 进程就是处理执行状态的代码以及相关资源的集合，包括代码端段、文件、信号、CPU状态、内存地址空间等。

进程使用task_struct结构体来描述，如下所示：

• 代码段：编译后形成的一些指令
• 数据段：程序运行时需要的数据
• 只读数据段：常量
• 已初始化数据段：全局变量，静态变量
• 未初始化数据段（bss)：未初始化的全局变量和静态变量
• 堆栈段：程序运行时动态分配的一些内存
• PCB：进程信息，状态标识等

关于进程的更多详细信息，读者可以去翻阅Linux相关书籍，这里只是给读者带来一种整体上的理解，我们的重心还是放在进程再Android平台上的应用。

在文章开篇的时候，我们提到了系统中运行的各种进程，那么这些进程如何被创建呢？🤔

我们先来看看我们最熟悉的应用进程是如何被创建的，前面我们已经说来每一个应用都运行在一个单独的进程里，当ActivityManagerService去启动四大组件时， 如果发现这个组件所在的进程没有启动，就会去创建一个新的进程，启动进程的时机我们在分析四大组件的启动流程的时候也有讲过，这里再总结一下：

• Activity ActivityStackSupervisor.startSpecificActivityLocked()
• Service ActiveServices.bringUpServiceLocked()
• ContentProvider ActivityManagerService.getContentProviderImpl() = Broadcast BroadcastQueue.processNextBroadcast()

这个新进程就是zygote进程通过复制自身来创建的，新进程在启动的过程中还会创建一个Binder线程池（用来做进程通信）和一个消息循环（用来做线程通信） 整个流程如下图所示：

1. 当我们点击应用图标启动应用时或者在应用内启动一个带有process标签的Activity时，都会触发创建新进程的请求，这种请求会先通过Binder 发送给system_server进程，也即是发送给ActivityManagerService进行处理。
2. system_server进程会调用Process.start()方法，会先收集uid、gid等参数，然后通过Socket方式发送给Zygote进程，请求创建新进程。
3. Zygote进程接收到创建新进程的请求后，调用ZygoteInit.main()方法进行runSelectLoop()循环体内，当有客户端连接时执行ZygoteConnection.runOnce() 方法，最后fork生成新的应用进程。
4. 新创建的进程会调用handleChildProc()方法，最后调用我们非常熟悉的ActivityThread.main()方法。

注：整个流程会涉及Binder和Socket两种进程通信方式，这个我们后续会有专门的文章单独分析，这个就不再展开。

整个流程大致就是这样，我们接着来看看具体的代码实现，先来看一张进程启动序列图：

从第一步到第三步主要是收集整理uid、gid、groups、target-sdk、nice-name等一系列的参数，为后续启动新进程做准备。然后调用openZygoteSocketIfNeeded()方法 打开Socket通信，向zygote进程发出创建新进程的请求。

注：第二步中的Process.start()方法是个阻塞操作，它会一直等待进程创建完毕，并返回pid才会完成该方法。

我们来重点关注几个关键的函数。

1.1 Process.openZygoteSocketIfNeeded(String abi)

关于Process类与Zygote进程的通信是如何进行的呢？🤔

Process的静态内部类ZygoteState有个成员变量LocalSocket对象，它会与ZygoteInit类的成员变量LocalServerSocket对象建立连接，如下所示：

客户端

public static class ZygoteState {
final LocalSocket socket;
}

服务端

public class ZygoteInit {
//该Socket与/dev/socket/zygote文件绑定在一起
private static LocalServerSocket sServerSocket;
}

我们来具体看看代码里的实现。

public static class ZygoteState {

public static ZygoteState connect(String socketAddress) throws IOException {
DataInputStream zygoteInputStream = null;
BufferedWriter zygoteWriter = null;
//创建LocalSocket对象
final LocalSocket zygoteSocket = new LocalSocket();

try {
//将LocalSocket与LocalServerSocket建立连接，建立连接的过程就是
//LocalSocket对象在/dev/socket目录下查找一个名称为"zygote"的文件
//然后将自己与其绑定起来，这样就建立了连接。
zygoteSocket.connect(new LocalSocketAddress(socketAddress,
LocalSocketAddress.Namespace.RESERVED));

//创建LocalSocket的输入流，以便可以接收Zygote进程发送过来的数据
zygoteInputStream = new DataInputStream(zygoteSocket.getInputStream());

//创建LocalSocket的输出流，以便可以向Zygote进程发送数据。
zygoteWriter = new BufferedWriter(new OutputStreamWriter(
zygoteSocket.getOutputStream()), 256);
} catch (IOException ex) {
try {
zygoteSocket.close();
} catch (IOException ignore) {
}

throw ex;
}

String abiListString = getAbiList(zygoteWriter, zygoteInputStream);
Log.i(“Zygote”, "Process: zygote socket opened, supported ABIS: " + abiListString);

return new ZygoteState(zygoteSocket, zygoteInputStream, zygoteWriter,
Arrays.asList(abiListString.split(“,”)));
}
}

建立Socket连接的流程很明朗了，如下所示：

1. 创建LocalSocket对象。
2. 将LocalSocket与LocalServerSocket建立连接，建立连接的过程就是LocalSocket对象在/dev/socket目录下查找一个名称为"zygote"的文件，然后将自己与其绑定起来，这样就建立了连接。
3. 创建LocalSocket的输入流，以便可以接收Zygote进程发送过来的数据。
4. 创建LocalSocket的输出流，以便可以向Zygote进程发送数据。

1.2 ZygoteInit.main(String argv[])

ZygoteInit是Zygote进程的启动类，该类会预加载一些类，然后便开启一个循环，等待通过Socket发过来的创建新进程的命令，fork出新的 子进程。

ZygoteInit的入口函数就是main()方法，如下所示：

public class ZygoteInit {

public static void main(String argv[]) {
// Mark zygote start. This ensures that thread creation will throw
// an error.
ZygoteHooks.startZygoteNoThreadCreation();

try {
//…
registerZygoteSocket(socketName);
//…
//开启循环
runSelectLoop(abiList);

closeServerSocket();
} catch (MethodAndArgsCaller caller) {
caller.run();
} catch (Throwable ex) {
Log.e(TAG, “Zygote died with exception”, ex);
closeServerSocket();
throw ex;
}
}

// 开启一个选择循环，接收通过Socket发过来的命令，创建新线程
private static void runSelectLoop(String abiList) throws MethodAndArgsCaller {

ArrayList fds = new ArrayList();
ArrayList peers = new ArrayList();

//sServerSocket指的是Socket通信的服务端，在fds中的索引为0
fds.add(sServerSocket.getFileDescriptor());
peers.add(null);

//开启循环
while (true) {
StructPollfd[] pollFds = new StructPollfd[fds.size()];
for (int i = 0; i < pollFds.length; ++i) {
pollFds[i] = new StructPollfd();
pollFds[i].fd = fds.get(i);
pollFds[i].events = (short) POLLIN;
}
try {
//处理轮询状态，当pollFds有时间到来时则往下执行，否则阻塞在这里。
Os.poll(pollFds, -1);
} catch (ErrnoException ex) {
throw new RuntimeException(“poll failed”, ex);
}
for (int i = pollFds.length - 1; i >= 0; --i) {

//采用IO多路复用机制，当接收到客户端发出的连接请求时或者数据处理请求到来时则
//往下执行，否则进入continue跳出本次循环。
if ((pollFds[i].revents & POLLIN) == 0) {
continue;
}
//索引为0，即为sServerSocket，表示接收到客户端发来的连接请求。
if (i == 0) {
ZygoteConnection newPeer = acceptCommandPeer(abiList);
peers.add(newPeer);
fds.add(newPeer.getFileDesciptor());
}
//索引不为0，表示通过Socket接收来自对端的数据，并执行相应的操作。
else {
boolean done = peers.get(i).runOnce();
//处理完成后移除相应的文件描述符。
if (done) {
peers.remove(i);
fds.remove(i);
}
}
}
}
}
}

可以发现ZygoteInit在其入口函数main()方法里调用runSelectLoop()开启了循环，接收Socket发来的请求。请求分为两种：

1. 连接请求
2. 数据请求

没有连接请求时Zygote进程会进入休眠状态，当有连接请求到来时，Zygote进程会被唤醒，调用acceptCommadPeer()方法创建Socket通道ZygoteConnection

private static ZygoteConnection acceptCommandPeer(String abiList) {
try {
return new ZygoteConnection(sServerSocket.accept(), abiList);
} catch (IOException ex) {
throw new RuntimeException(
“IOException during accept()”, ex);
}
}

然后调用runOnce()方法读取连接请求里的数据，然后创建新进程。

此外，连接的过程中服务端接受的到客户端的connect()操作会执行accpet()操作，建立连接手，客户端通过write()写数据，服务端通过read()读数据。

1.3 ZygoteConnection.runOnce()

class ZygoteConnection {

boolean runOnce() throws ZygoteInit.MethodAndArgsCaller {

String args[];
Arguments parsedArgs = null;
FileDescriptor[] descriptors;

try {
//读取客户端发过来的参数列表
args = readArgumentList();
descriptors = mSocket.getAncillaryFileDescriptors();
} catch (IOException ex) {
Log.w(TAG, "IOException on command socket " + ex.getMessage());
closeSocket();
return true;
}

//… 参数处理

try {

//… 参数处理

//调用Zygote.forkAndSpecialize（来fork出新进程
pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,
parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,
parsedArgs.niceName, fdsToClose, parsedArgs.instructionSet,
parsedArgs.appDataDir);
} catch (ErrnoException ex) {
logAndPrintError(newStderr, “Exception creating pipe”, ex);
} catch (IllegalArgumentException ex) {
logAndPrintError(newStderr, “Invalid zygote arguments”, ex);
} catch (ZygoteSecurityException ex) {
logAndPrintError(newStderr,
"Zygote security policy prevents request: ", ex);
}

try {
//pid == 0时表示当前是在新创建的子进程重磅执行
if (pid == 0) {
// in child
IoUtils.closeQuietly(serverPipeFd);
serverPipeFd = null;
handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);

// should never get here, the child is expected to either
// throw ZygoteInit.MethodAndArgsCaller or exec().
return true;
}
// pid < 0表示创建新进程失败，pid > 0 表示当前是在父进程中执行
else {
// in parent…pid of < 0 means failure
IoUtils.closeQuietly(childPipeFd);
childPipeFd = null;
return handleParentProc(pid, descriptors, serverPipeFd, parsedArgs);
}
} finally {
IoUtils.closeQuietly(childPipeFd);
IoUtils.closeQuietly(serverPipeFd);
}
}
}

该方法主要用来读取进程启动参数，然后调用Zygote.forkAndSpecialize()方法fork出新进程，该方法是创建新进程的核心方法，它主要会陆续调用三个 方法来完成工作：

1. preFork()：先停止Zygote进程的四个Daemon子线程的运行以及初始化GC堆。这四个Daemon子线程分别为：Java堆内存管理现场、堆线下引用队列线程、析构线程与监控线程。
2. nativeForkAndSpecialize()：调用Linux系统函数fork()创建新进程，创建Java堆处理的线程池，重置GC性能数据，设置进程的信号处理函数，启动JDWP线程。
3. postForkCommon()：启动之前停止的Zygote进程的四个Daemon子线程。

上面的方法都完成会后，新进程会创建完成，并返回pid，接着就调用handleChildProc()来启动新进程。handleChildProc()方法会接着调用RuntimeInit.zygoteInit()来 完成新进程的启动。

1.4 RuntimeInit.zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)

这个就是个关键的方法了，它主要用来创建一些运行时环境，我们来看一看。

public class RuntimeInit {

public static final void zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
throws ZygoteInit.MethodAndArgsCaller {
if (DEBUG) Slog.d(TAG, “RuntimeInit: Starting application from zygote”);

Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, “RuntimeInit”);
redirectLogStreams();
//创建应用进程的时区和键盘等通用信息
commonInit();
//在应用进程中创建一个Binder线程池
nativeZygoteInit();
//创建应用信息
applicationInit(targetSdkVersion, argv, classLoader);
}
}

该方法主要完成三件事：

1. 调用commonInit()方法创建应用进程的时区和键盘等通用信息。
2. 调用nativeZygoteInit()方法在应用进程中创建一个Binder线程池。
3. 调用applicationInit(targetSdkVersion, argv, classLoader)方法创建应用信息。

Binder线程池我们后续的文章会分析，我们重点来看看applicationInit(targetSdkVersion, argv, classLoader)方法的实现，它主要用来完成应用的创建。

该方法里的argv参数指的就是ActivityThread，该方法会调用invokeStaticMain()通过反射的方式调用ActivityThread类的main()方法。如下所示：

public class RuntimeInit {

private static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
throws ZygoteInit.MethodAndArgsCaller {
//…

// Remaining arguments are passed to the start class’s static main
invokeStaticMain(args.startClass, args.startArgs, classLoader);
}

private static void invokeStaticMain(String className, String[] argv, ClassLoader classLoader)
throws ZygoteInit.MethodAndArgsCaller {
Class<?> cl;

//通过反射调用ActivityThread类的main()方法
try {
cl = Class.forName(className, true, classLoader);
} catch (ClassNotFoundException ex) {
throw new RuntimeException(
"Missing class when invoking static main " + className,
ex);
}

Method m;
try {
m = cl.getMethod(“main”, new Class[] { String[].class });
} catch (NoSuchMethodException ex) {
throw new RuntimeException(
"Missing static main on " + className, ex);
} catch (SecurityException ex) {
throw new RuntimeException(
"Problem getting static main on " + className, ex);
}
//…
}
}

走到ActivityThread类的main()方法，我们就很熟悉了，我们知道在main()方法里，会创建主线程Looper，并开启消息循环，如下所示：

public final class ActivityThread {

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

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

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

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

如果你觉得这些内容对你有帮助，可以添加V获取：vip204888 （备注Android）

最后

其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。

下图是我进阶学习所积累的历年腾讯、头条、阿里、美团、字节跳动等公司2019-2021年的高频面试题，博主还把这些技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节

整理不易，望各位看官老爷点个关注转发，谢谢！祝大家都能得到自己心仪工作。

讲义、实战项目、讲解视频，并且后续会持续更新**

如果你觉得这些内容对你有帮助，可以添加V获取：vip204888 （备注Android）
[外链图片转存中…(img-9kSZ7JJU-1712078587055)]

最后

其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。

下图是我进阶学习所积累的历年腾讯、头条、阿里、美团、字节跳动等公司2019-2021年的高频面试题，博主还把这些技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节

[外链图片转存中…(img-dFNSHP6e-1712078587056)]

整理不易，望各位看官老爷点个关注转发，谢谢！祝大家都能得到自己心仪工作。

本文已被CODING开源项目：《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》收录