Java 世界的盘古和女娲 —— Zygote
本文基于 android 9.0 , 代码仓库地址 ：
文中源码链接：
仔细看看下面这张 android 体系图，找一下 zygote 在什么地方。
上图来自 gityuan 博客 。
纵观整个 android 体系结构，底层内核空间以 linux kernel 为核心，上层用户空间以 c++/java 组成的 framework 层组成，通过系统调用来连接用户空间和内核空间。而用户空间又分为 native 世界和 java 世界，通过 jni 技术进行连接。native 世界的 init 进程是所有用户进程的祖先，其 pid 为 1 。init 进程通过解析 init.rc 文件创建出 zygote 进程，zygote 进程人如其名，翻译成中文就是 受精卵 的意思。它是 java 世界的中的第一个进程，也是 android 系统中的第一个 java 进程，颇有盘古开天辟地之势。
zygote 创建的第一个进程就是 system server，system server 负责管理和启动整个 java framework 层。创建完 system server 之后，zygote 就会完全进入受精卵的角色，等待进行无性繁殖，创建应用进程。所有的应用进程都是由 zygote 进程 fork 而来的，称之为 java 世界的女娲也不足为过。
zygote 的启动过程是从 native 层开始的，这里不会 native 层作过多分析，直接进入其在 java 世界的入口 zygoteinit.main() :
public static void main(string argv[]) {
zygoteserver zygoteserver = new zygoteserver();
// mark zygote start. this ensures that thread creation will throw
// an error.
zygotehooks.startzygotenothreadcreation();
// zygote goes into its own process group.
// 设置进程组 id
// pid 为 0 表示设置当前进程的进程组 id
// gid 为 0 表示使用当前进程的 pid 作为进程组 id
try {
os.setpgid(0, 0);
} catch (errnoexception ex) {
throw new runtimeexception("failed to setpgid(0,0)", ex);
}
final runnable caller;
try {
......
runtimeinit.enableddms(); // 启用 ddms
boolean startsystemserver = false;
string socketname = "zygote";
string abilist = null;
boolean enablelazypreload = false;
for (int i = 1; i < argv.length; i++) { // 参数解析
if ("start-system-server".equals(argv[i])) {
startsystemserver = true;
} else if ("--enable-lazy-preload".equals(argv[i])) {
enablelazypreload = true;
} else if (argv[i].startswith(abi_list_arg)) {
abilist = argv[i].substring(abi_list_arg.length());
} else if (argv[i].startswith(socket_name_arg)) {
socketname = argv[i].substring(socket_name_arg.length());
} else {
throw new runtimeexception("unknown command line argument: " + argv[i]);
}
}
if (abilist == null) {
throw new runtimeexception("no abi list supplied.");
}
// 1. 注册服务端 socket，这里的 ipc 不是 binder 通信
zygoteserver.registerserversocketfromenv(socketname);
// in some configurations, we avoid preloading resources and classes eagerly.
// in such cases, we will preload things prior to our first fork.
if (!enablelazypreload) {
boottimingstracelog.tracebegin("zygotepreload");
eventlog.writeevent(log_boot_progress_preload_start,
systemclock.uptimemillis());
preload(boottimingstracelog); // 2. 预加载操作
eventlog.writeevent(log_boot_progress_preload_end,
systemclock.uptimemillis());
boottimingstracelog.traceend(); // zygotepreload
} else {
zygote.resetnicepriority(); // 设置线程优先级为 norm_priority (5)
}
// do an initial gc to clean up after startup
gcandfinalize(); // 3. 强制进行一次垃圾收集
zygote.nativesecurityinit();
// zygote process unmounts root storage spaces.
zygote.nativeunmountstorageoninit();
zygotehooks.stopzygotenothreadcreation();
if (startsystemserver) {
// 4. 启动systemserver 进程
runnable r = forksystemserver(abilist, socketname, zygoteserver);
// {@code r == null} in the parent (zygote) process, and {@code r != null} in the
// child (system_server) process.
if (r != null) {
r.run(); // 由 runtimeinit.java 中的 methodandargscaller 反射调用systemserver 的 main() 方法
return;
}
}
log.i(tag, "accepting command socket connections");
// the select loop returns early in the child process after a fork and
// loops forever in the zygote.
// 5. 循环等待处理客户端请求
caller = zygoteserver.runselectloop(abilist);
} catch (throwable ex) {
log.e(tag, "system zygote died with exception", ex);
throw ex;
} finally {
zygoteserver.closeserversocket(); // 关闭并释放 socket 连接
}
// we're in the child process and have exited the select loop. proceed to execute the
// command.
if (caller != null) {
caller.run();
}
}
省去部分不是那么重要的代码，zygoteinit.main() 方法大致可以分为以下五个步骤：
-
registerserversocketfromenv， 注册服务端 socket，用于跨进程通信，这里并没有使用 binder 通信。 -
preload()，进行预加载操作 -
gcandfinalize()，在 forksystemserver 之前主动进行一次垃圾回收 -
forksystemserver()，创建 systemserver 进程 -
runselectloop()，循环等待处理客户端发来的 socket 请求
上面基本上就是 zygote 的全部使命了，下面按照这个流程来详细分析。
registerserversocketfromenv
> zygoteserver.java
void registerserversocketfromenv(string socketname) {
if (mserversocket == null) {
int filedesc;
final string fullsocketname = android_socket_prefix + socketname;
try {
// 从环境变量中获取 socket 的 fd
string env = system.getenv(fullsocketname);
filedesc = integer.parseint(env);
} catch (runtimeexception ex) {
throw new runtimeexception(fullsocketname + " unset or invalid", ex);
}
try {
filedescriptor fd = new filedescriptor();
fd.setint$(filedesc); // 设置文件描述符
mserversocket = new localserversocket(fd); // 创建服务端 socket
mclosesocketfd = true;
} catch (ioexception ex) {
throw new runtimeexception(
"error binding to local socket '" + filedesc + "'", ex);
}
}
}
首先从环境变量中获取 socket 的文件描述符 fd，然后根据 fd 创建服务端 localserversocket，用于 ipc 通信。这里的环境变量是在 init 进程创建 zygote 进程时设置的。
preload()
> zygoteinit.java
static void preload(timingstracelog boottimingstracelog) {
......
preloadclasses(); // 预加载并初始化 /system/etc/preloaded-classes 中的类
......
preloadresources(); // 预加载系统资源
......
nativepreloadappprocesshals(); // hal?
......
preloadopengl(); // 预加载 opengl
......
preloadsharedlibraries(); // 预加载 共享库，包括 android、compiler_rt、jnigraphics 这三个库
preloadtextresources(); // 预加载文字资源
// ask the webviewfactory to do any initialization that must run in the zygote process,
// for memory sharing purposes.
// webviewfactory 中一些必须在 zygote 进程中进行的初始化工作，用于共享内存
webviewfactory.preparewebviewinzygote();
warmupjcaproviders();
spreloadcomplete = true;
}
preload() 方法主要进行一些类，资源，共享库的预加载工作，以提升运行时效率。下面依次来看一下都预加载了哪些内容。
preloadclasses()
> zygoteinit.java
private static void preloadclasses() {
......
inputstream is;
try {
// /system/etc/preloaded-classes
is = new fileinputstream(preloaded_classes);
} catch (filenotfoundexception e) {
log.e(tag, "couldn't find " + preloaded_classes + ".");
return;
}
try {
bufferedreader br
= new bufferedreader(new inputstreamreader(is), 256);
int count = 0;
string line;
while ((line = br.readline()) != null) {
// skip comments and blank lines.
line = line.trim();
if (line.startswith("#") || line.equals("")) {
continue;
}
try {
// load and explicitly initialize the given class. use
// class.forname(string, boolean, classloader) to avoid repeated stack lookups
// (to derive the caller's class-loader). use true to force initialization, and
// null for the boot classpath class-loader (could as well cache the
// class-loader of this class in a variable).
class.forname(line, true, null);
count++;
} catch (classnotfoundexception e) {
log.w(tag, "class not found for preloading: " + line);
} catch (unsatisfiedlinkerror e) {
log.w(tag, "problem preloading " + line + ": " + e);
} catch (throwable t) {
......
}
}
} catch (ioexception e) {
log.e(tag, "error reading " + preloaded_classes + ".", e);
} finally {
ioutils.closequietly(is);
......
}
}
只保留了核心逻辑代码。读取 /system/etc/preloaded-classes 文件，并通过 class.forname() 方法逐行加载文件中声明的类。提前预加载系统常用的类无疑可以提升运行时效率，但是这个预加载常用类的工作通常都会很重。搜索整个源码库，在 /frameworks/base/config 目录下发现一份 preloaded-classes 文件，打开这个文件，一共 6558 行，这就意味着要提前加载数千个类，这无疑会消耗很长时间，以增加 android 系统启动时间的代价提升了运行时的效率。
preloadresources()
> zygoteinit.java
private static void preloadresources() {
final vmruntime runtime = vmruntime.getruntime();
try {
mresources = resources.getsystem();
mresources.startpreloading();
if (preload_resources) {
typedarray ar = mresources.obtaintypedarray(
com.android.internal.r.array.preloaded_drawables);
int n = preloaddrawables(ar);
ar.recycle();
......
ar = mresources.obtaintypedarray(
com.android.internal.r.array.preloaded_color_state_lists);
n = preloadcolorstatelists(ar);
ar.recycle();
if (mresources.getboolean(
com.android.internal.r.bool.config_freeformwindowmanagement)) {
ar = mresources.obtaintypedarray(
com.android.internal.r.array.preloaded_freeform_multi_window_drawables);
n = preloaddrawables(ar);
ar.recycle();
}
}
mresources.finishpreloading();
} catch (runtimeexception e) {
log.w(tag, "failure preloading resources", e);
}
}
从源码中可知，主要加载的资源有：
com.android.internal.r.array.preloaded_drawables
com.android.internal.r.array.preloaded_color_state_lists
com.android.internal.r.array.preloaded_freeform_multi_window_drawables
preloadsharedlibraries()
> zygoteinit.java
private static void preloadsharedlibraries() {
log.i(tag, "preloading shared libraries...");
system.loadlibrary("android");
system.loadlibrary("compiler_rt");
system.loadlibrary("jnigraphics");
}
预加载了三个共享库，libandroid.so 、libcompiler_rt.so 和 libjnigraphics.so 。
gcandfinalize()
> zygoteinit.java
static void gcandfinalize() {
final vmruntime runtime = vmruntime.getruntime();
/* runfinalizationsync() lets finalizers be called in zygote,
* which doesn't have a heapworker thread.
*/
system.gc();
runtime.runfinalizationsync();
system.gc();
}
在 forksystemserver() 之前会主动进行一次 gc 操作。
forksystemserver()
主动调用 gc 之后，zygote 就要去做它的大事 —— fork systemserver 进程了。
> zygoteinit.java
private static runnable forksystemserver(string abilist, string socketname,
......
/* hardcoded command line to start the system server */
// 启动参数
string args[] = {
"--setuid=1000",
"--setgid=1000",
"--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1023,1024,1032,1065,3001,3002,3003,3006,3007,3009,3010",
"--capabilities=" + capabilities + "," + capabilities,
"--nice-name=system_server", // 进程名
"--runtime-args",
"--target-sdk-version=" + vmruntime.sdk_version_cur_development,
"com.android.server.systemserver", // 加载类名
};
zygoteconnection.arguments parsedargs = null;
int pid;
try {
parsedargs = new zygoteconnection.arguments(args);
zygoteconnection.applydebuggersystemproperty(parsedargs);
zygoteconnection.applyinvokewithsystemproperty(parsedargs);
boolean profilesystemserver = systemproperties.getboolean(
"dalvik.vm.profilesystemserver", false);
if (profilesystemserver) {
parsedargs.runtimeflags |= zygote.profile_system_server;
}
/* request to fork the system server process
* fork system_server 进程
*/
pid = zygote.forksystemserver(
parsedargs.uid, parsedargs.gid,
parsedargs.gids,
parsedargs.runtimeflags,
null,
parsedargs.permittedcapabilities,
parsedargs.effectivecapabilities);
} catch (illegalargumentexception ex) {
throw new runtimeexception(ex);
}
/* for child process */
// pid == 0 表示子进程，从这里开始进入 system_server 进程
if (pid == 0) {
if (hassecondzygote(abilist)) { // 如果有第二个 zygote
waitforsecondaryzygote(socketname);
}
zygoteserver.closeserversocket(); // 关闭并释放从 zygote copy 过来的 socket
return handlesystemserverprocess(parsedargs); // 完成新创建的 system_server 进程的剩余工作
}
/**
* 注意 fork() 函数式一次执行，两次返回（两个进程对同一程序的两次执行）。
* pid > 0 说明还是父进程。pid = 0 说明进入了子进程
* 所以这里的 return null 依旧会执行
*/
return null;
}
从上面的启动参数可以看到，systemserver 进程的 uid 和 gid 都是 1000，进程名是 system_server ，其最后要加载的类名是 com.android.server.systemserver 。准备好一系列参数之后通过 zygoteconnection.arguments() 拼接，接着调用 zygote.forksystemserver() 方法真正的 fork 出子进程 system_server。
> zygote.java
public static int forksystemserver(int uid, int gid, int[] gids, int runtimeflags,
int[][] rlimits, long permittedcapabilities, long effectivecapabilities) {
vm_hooks.prefork();
// resets nice priority for zygote process.
resetnicepriority();
int pid = nativeforksystemserver(
uid, gid, gids, runtimeflags, rlimits, permittedcapabilities, effectivecapabilities);
// enable tracing as soon as we enter the system_server.
if (pid == 0) {
trace.settracingenabled(true, runtimeflags);
}
vm_hooks.postforkcommon();
return pid;
}
native private static int nativeforksystemserver(int uid, int gid, int[] gids, int runtimeflags,
int[][] rlimits, long permittedcapabilities, long effectivecapabilities);
最后的 fork() 操作是在 native 层完成的。再回到 zygoteinit.forksystemserver() 中执行 fork() 之后的逻辑处理：
if(pid == 0){
......
return handlesystemserverprocess(parsedargs);
}
return null;
按正常逻辑思维，这两处 return 只会执行一次，其实不然。fork() 函数是一次执行，两次返回。说的更严谨一点是 两个进程对用一个程序的两次执行。当 pid == 0 时，说明现在处于子进程，当 pid > 0 时，说明处于父进程。在刚 fork 出子进程的时候，父子进程的数据结构基本是一样的，但是之后就分道扬镳了，各自执行各自的逻辑。所以上面的代码段中会有两次返回值，子进程 (system_server) 中会返回执行 handlesystemserverprocess(parsedargs) 的结果，父进程 (zygote) 会返回 null。对于两个不同的返回值又会分别做什么处理呢？我们回到 zygoteinit.main() 中：
if (startsystemserver) {
runnable r = forksystemserver(abilist, socketname, zygoteserver);
// {@code r == null} in the parent (zygote) process, and {@code r != null} in the
// child (system_server) process.
// r == null 说明是在 zygote 进程
// r != null 说明是在 system_server 进程
if (r != null) {
r.run();
return;
}
}
// 循环等待处理客户端请求
caller = zygoteserver.runselectloop(abilist);
子进程 system_server 返回的是一个 runnable，执行 r.run()，然后就直接 return 了。而父进程 zygote 返回的是 null，所以不满足 if 的判断条件，继续往下执行 runselectloop 。父子进程就此分道扬镳，各干各的事。
下面就来分析 runselectloop() 和 handlesystemserverprocess() 这两个方法，看看 zygote 和 systemserver 这对父子进程继续做了些什么工作。
handlesystemserverprocess
到这里其实已经脱离 zygote 的范畴了，本准备放在下一篇 systemserver 源码解析中再介绍，可是这里不写又觉得 zygote 介绍的不完整，索性就一并说了。
> zygoteinit.java
private static runnable handlesystemserverprocess(zygoteconnection.arguments parsedargs) {
// set umask to 0077 so new files and directories will default to owner-only permissions.
// umask一般是用在你初始创建一个目录或者文件的时候赋予他们的权限
os.umask(s_irwxg | s_irwxo);
// 设置当前进程名为 "system_server"
if (parsedargs.nicename != null) {
process.setargv0(parsedargs.nicename);
}
final string systemserverclasspath = os.getenv("systemserverclasspath");
if (systemserverclasspath != null) {
// dex 优化操作
performsystemserverdexopt(systemserverclasspath);
// capturing profiles is only supported for debug or eng builds since selinux normally
// prevents it.
boolean profilesystemserver = systemproperties.getboolean(
"dalvik.vm.profilesystemserver", false);
if (profilesystemserver && (build.is_userdebug || build.is_eng)) {
try {
preparesystemserverprofile(systemserverclasspath);
} catch (exception e) {
log.wtf(tag, "failed to set up system server profile", e);
}
}
}
if (parsedargs.invokewith != null) { // invokewith 一般为空
string[] args = parsedargs.remainingargs;
// if we have a non-null system server class path, we'll have to duplicate the
// existing arguments and append the classpath to it. art will handle the classpath
// correctly when we exec a new process.
if (systemserverclasspath != null) {
string[] amendedargs = new string[args.length + 2];
amendedargs[0] = "-cp";
amendedargs[1] = systemserverclasspath;
system.arraycopy(args, 0, amendedargs, 2, args.length);
args = amendedargs;
}
wrapperinit.execapplication(parsedargs.invokewith,
parsedargs.nicename, parsedargs.targetsdkversion,
vmruntime.getcurrentinstructionset(), null, args);
throw new illegalstateexception("unexpected return from wrapperinit.execapplication");
} else {
classloader cl = null;
if (systemserverclasspath != null) {
// 创建类加载器，并赋给当前线程
cl = createpathclassloader(systemserverclasspath, parsedargs.targetsdkversion);
thread.currentthread().setcontextclassloader(cl);
}
/*
* pass the remaining arguments to systemserver.
*/
return zygoteinit.zygoteinit(parsedargs.targetsdkversion, parsedargs.remainingargs, cl);
}
/* should never reach here */
}
设置进程名为 system_server，执行 dex 优化，给当前线程设置类加载器，最后调用 zygoteinit.zygoteinit() 继续处理剩余参数。
public static final runnable zygoteinit(int targetsdkversion, string[] argv, classloader classloader) {
......
// redirect system.out and system.err to the android log.
// 重定向 system.out 和 system.err 到 android log
runtimeinit.redirectlogstreams();
runtimeinit.commoninit(); // 一些初始化工作
zygoteinit.nativezygoteinit(); // native 层初始化
return runtimeinit.applicationinit(targetsdkversion, argv, classloader); // 调用入口函数
}
重定向 log，进行一些初始化工作。这部分不细说了，点击文章开头给出的源码链接，大部分都做了注释。最后调用 runtimeinit.applicationinit() ，继续追进去看看。
> runtimeinit.java
protected static runnable applicationinit(int targetsdkversion, string[] argv,
classloader classloader) {
......
final arguments args = new arguments(argv); // 解析参数
......
// 寻找 startclass 的 main() 方法。这里的 startclass 是 com.android.server.systemserver
return findstaticmain(args.startclass, args.startargs, classloader);
}
这里的 startclass 参数是 com.android.server.systemserver。findstaticmain() 方法看名字就能知道它的作用是找到 main() 函数，这里是要找到 com.android.server.systemserver 类的 main() 方法。
protected static runnable findstaticmain(string classname, string[] argv,
classloader classloader) {
class<?> cl;
try {
cl = class.forname(classname, true, classloader);
} catch (classnotfoundexception ex) {
throw new runtimeexception(
"missing class when invoking static main " + classname,
ex);
}
method m;
try {
// 寻找 main() 方法
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);
}
int modifiers = m.getmodifiers();
if (! (modifier.isstatic(modifiers) && modifier.ispublic(modifiers))) {
throw new runtimeexception(
"main method is not public and static on " + classname);
}
/*
* this throw gets caught in zygoteinit.main(), which responds
* by invoking the exception's run() method. this arrangement
* clears up all the stack frames that were required in setting
* up the process.
* 返回一个 runnable，在 zygote 的 main() 方法中执行器 run() 方法
* 之前的版本是抛出一个异常，在 main() 方法中捕获
*/
return new methodandargscaller(m, argv);
}
找到 main() 方法并构建一个 runnable 对象 methodandargscaller 。这里返回的 runnable 对象会在哪里执行呢？又要回到文章开头的 zygoteinit.main() 函数了，在 forksystemserver() 之后，子进程执行 handlesystemserverprocess() 并返回一个 runnable 对象，在 zygoteinit.main() 中会执行其 run() 方法。
再来看看 methodandargscaller 的 run() 方法吧！
static class methodandargscaller implements runnable {
/** method to call */
private final method mmethod;
/** argument array */
private final string[] margs;
public methodandargscaller(method method, string[] args) {
mmethod = method;
margs = args;
}
public void run() {
try {
mmethod.invoke(null, new object[] { margs });
} catch (illegalaccessexception ex) {
throw new runtimeexception(ex);
} catch (invocationtargetexception ex) {
throwable cause = ex.getcause();
if (cause instanceof runtimeexception) {
throw (runtimeexception) cause;
} else if (cause instanceof error) {
throw (error) cause;
}
throw new runtimeexception(ex);
}
}
}
就一件事，执行参数中的 method。这里的 method 就是 com.android.server.systemserver 的 main() 方法。到这里，systemserver 就要正式工作了。
其实在老版本的 android 源码中，并不是通过这种方法执行 systemserver.main() 的。老版本的 methodandargscaller 是 exception 的子类，在这里会直接抛出异常，然后在 zygoteinit.main() 方法中进行捕获，捕获之后执行其 run() 方法。
systemserver 的具体分析就放到下篇文章吧，本篇的主角还是 zygote ！
看到这里，zygote 已经完成了一件人生大事，孵化出了 systemserver 进程。但是作为 “女娲” ，造人的任务还是停不下来，任何一个应用进程的创建还是离不开它的。zygoteserver.runslectloop() 给它搭好了和客户端之前的桥梁。
runselectloop
> zygoteserver.java
runnable runselectloop(string abilist) {
arraylist<filedescriptor> fds = new arraylist<filedescriptor>();
arraylist<zygoteconnection> peers = new arraylist<zygoteconnection>();
// mserversocket 是之前在 zygote 中创建的
fds.add(mserversocket.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 {
// 有事件来时往下执行，没有时就阻塞
os.poll(pollfds, -1);
} catch (errnoexception ex) {
throw new runtimeexception("poll failed", ex);
}
for (int i = pollfds.length - 1; i >= 0; --i) {
if ((pollfds[i].revents & pollin) == 0) {
continue;
}
if (i == 0) { // 有新客户端连接
zygoteconnection newpeer = acceptcommandpeer(abilist);
peers.add(newpeer);
fds.add(newpeer.getfiledesciptor());
} else { // 处理客户端请求
try {
zygoteconnection connection = peers.get(i);
final runnable command = connection.processonecommand(this);
......
} catch (exception e) {
......
}
}
}
}
mserversocket 是 zygoteinit.main() 中一开始就建立的服务端 socket，用于处理客户端请求。一看到 while(true) 就肯定会有阻塞操作。os.poll() 在有事件来时往下执行，否则就阻塞。当有客户端请求过来时，调用 zygoteconnection.processonecommand() 方法来处理。
processonecommand() 源码很长，这里就贴一下关键部分：
......
pid = zygote.forkandspecialize(parsedargs.uid, parsedargs.gid, parsedargs.gids,
parsedargs.runtimeflags, rlimits, parsedargs.mountexternal, parsedargs.seinfo,
parsedargs.nicename, fdstoclose, fdstoignore, parsedargs.startchildzygote,
parsedargs.instructionset, parsedargs.appdatadir);
try {
if (pid == 0) {
// in child 进入子进程
zygoteserver.setforkchild();
zygoteserver.closeserversocket();
ioutils.closequietly(serverpipefd);
serverpipefd = null;
return handlechildproc(parsedargs, descriptors, childpipefd,
parsedargs.startchildzygote);
} else {
// in the parent. a pid < 0 indicates a failure and will be handled in
// handleparentproc.
ioutils.closequietly(childpipefd);
childpipefd = null;
handleparentproc(pid, descriptors, serverpipefd);
return null;
}
} finally {
ioutils.closequietly(childpipefd);
ioutils.closequietly(serverpipefd);
}
乍一看是不是感觉有点眼熟？没错，这一块的逻辑和 forksystemserver() 很相似，只是这里 fork 的是普通应用进程，调用的是 forkandspecialize() 方法。中间的代码调用就不在这详细分析了，最后还是会调用到 findstaticmain() 执行应用进程的对应 main() 方法，感兴趣的同学可以到我的源码项目 阅读相关文件，注释还是比较多的。
还有一个问题，上面只分析了 zygote 接收到客户端请求并响应，那么这个客户端可能是谁呢？具体又是如何与 zygote 通信的呢？关于这个问题，后续文章中肯定会写到，关注我的 github 仓库 ，所有文章都会第一时间同步过去。
总结
来一张时序图总结全文 ：
最后想说说如何阅读 aosp 源码和开源项目源码。我的看法是，不要上来就拼命死磕，一行一行的非要全部看懂。首先要理清脉络，能大致的理出来一个时序图，然后再分层细读。这个细读的过程中碰到不懂的知识点就得自己去挖掘，比如文中遇到的 forksystemserver() 为什么会返回两次？当然，对于实在超出自己知识范畴的内容，也可以选择性的暂时跳过，日后再战。最后的最后，来篇技术博客吧！理清，看懂，表达，都会逐步加深你对源码的了解程度，还能分享知识，反馈社区，何乐而不为呢？
下篇文章会具体说说 systemserver 进程具体都干了些什么。
文章首发微信公众号：
秉心说， 专注 java 、 android 原创知识分享，leetcode 题解。更多最新原创文章，扫码关注我吧！