安卓系统启动之Zygote进程启动过程
背景
安卓系统启动时首先启动init进程，而后init进程会创建zygote进程，zygote进程则会fork出来SystemServer进程。在安卓开发学习之SystemServer启动过程一文中记录了阅读SystemServer启动的过程，现在就记录一下Zygote进程的启动过程
源码阅读
Zygote进程的启动源自于ZygoteInit类的入口main()方法
ZygoteInit#main()
main()方法代码如下
public static void main(String argv[]) {
ZygoteServer zygoteServer = new ZygoteServer();
ZygoteHooks.startZygoteNoThreadCreation(); // 启动hook跟踪
try {
Os.setpgid(0, 0);
// 指定当前进程的id(第一个参数是目标进程id，第二个参数是进程组id，把第二个参数设置成第一个的值)
} catch (ErrnoException ex) {
.. // 异常
}
try {
if (!"1".equals(SystemProperties.get("sys.boot_completed"))) {
// 如果是重启sys.boot_completed值是1
MetricsLogger.histogram(null, "boot_zygote_init",
(int) SystemClock.elapsedRealtime());
} // 上报Zygote进程启动的时间，除非是进程重启
.. // 日志跟踪
RuntimeInit.enableDdms(); // 启动ddms
SamplingProfilerIntegration.start(); // 用于系统优化
boolean startSystemServer = false;
String socketName = "zygote"; // 进程套接字名字时zygote
String abiList = null; // abi列表(armeabi、armeabi-v7a、x86等)
boolean enableLazyPreload = false;
for (int i = 1; i < argv.length; i++) { // 遍历参数列表
if ("start-system-server".equals(argv[i])) {
startSystemServer = true; // 是否启动SystemServer进程，一般都要启动
} 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()); // 获取abi列表
} else if (argv[i].startsWith(SOCKET_NAME_ARG)) {
socketName = argv[i].substring(SOCKET_NAME_ARG.length()); // 获取套接字名字
} else {
.. // 异常
}
}
if (abiList == null) {
.. // 异常
}
zygoteServer.registerServerSocket(socketName); // 注册套接字
if (!enableLazyPreload) { // 如果不启动懒人式预加载
..
preload(bootTimingsTraceLog); // 就调用preload()方法进行预加载
..
} else {
Zygote.resetNicePriority(); // 启动懒人式预加载的话，就只重置fifo策略
}
SamplingProfilerIntegration.writeZygoteSnapshot(); // 保存快照
..
gcAndFinalize(); // 进行gc
..
Zygote.nativeUnmountStorageOnInit(); // 卸载root的存储空间
Seccomp.setPolicy(); // seccomp安全模式
ZygoteHooks.stopZygoteNoThreadCreation();
if (startSystemServer) {
startSystemServer(abiList, socketName, zygoteServer); // 启动SystemServer
}
..
zygoteServer.runSelectLoop(abiList); // zygote进程进入死循环，不断准备接收新的socket连接
zygoteServer.closeServerSocket(); // 关闭zygote套接字
} catch (Zygote.MethodAndArgsCaller caller) {
caller.run(); // 启动SystemServer时，最终会到这里调用SystemServer.main()
} catch (Throwable ex) {
Log.e(TAG, "System zygote died with exception", ex);
zygoteServer.closeServerSocket();
throw ex;
}
}第一次启动的话，肯定不会是懒人预加载，肯定会调用preload()方法进行初始化，这个方法代码如下
static void preload(BootTimingsTraceLog bootTimingsTraceLog) {
..
beginIcuCachePinning(); // 指令缓存
..
preloadClasses(); // 利用反射进行某些类的预加载
..
preloadResources(); // 预加载资源
..
preloadOpenGL(); // 预加载openGL
..
preloadSharedLibraries(); // 预加载native库
preloadTextResources(); // 预加载文字资源
WebViewFactory.prepareWebViewInZygote(); // 在zygote进程就预加载了webview
endIcuCachePinning(); // 结束指令缓存
warmUpJcaProviders(); // 预加载jca加密缓存
..
sPreloadComplete = true;
}原来系统资源以及一些库的初始化都在zygote进程里就进行了，特别是webView的预加载也是这么早。
回到main()方法，然后一个比较重要的方法是startSystemServer()方法，因为这个方法会启动SystemServer进程
ZygoteInit#startSystemServer()
这个方法代码如下
private static boolean startSystemServer(String abiList, String socketName, ZygoteServer zygoteServer)
throws Zygote.MethodAndArgsCaller, RuntimeException {
long capabilities = posixCapabilitiesAsBits(
OsConstants.CAP_IPC_LOCK, // IPC通信时获取锁
OsConstants.CAP_KILL, // 绕过权限检查直接向别的进程发信号
OsConstants.CAP_NET_ADMIN, // 网络管理
OsConstants.CAP_NET_BIND_SERVICE, // 绑定到1024以下的端口
OsConstants.CAP_NET_BROADCAST, // 广播
OsConstants.CAP_NET_RAW, // 使用原始套接字
OsConstants.CAP_SYS_MODULE, // 对系统内核模块进行插入删除
OsConstants.CAP_SYS_NICE, // 禁止普通用户进行线程的FIFO调度策略
OsConstants.CAP_SYS_PTRACE, // 进程跟踪
OsConstants.CAP_SYS_TIME, // 系统时间
OsConstants.CAP_SYS_TTY_CONFIG, // 配置tty(终端)信息
OsConstants.CAP_WAKE_ALARM // 系统闹钟
); // 初始化要赋予SystemServer进程的能力
if (!SystemProperties.getBoolean(PROPERTY_RUNNING_IN_CONTAINER, false)) {
// 如果系统属性PROPERTY_RUNNING_IN_CONTAINER的值是false
// 就在要赋予SystemServer的能力里加上CAP_BLOCK_SUSPEND(阻止系统进程挂起)
capabilities |= posixCapabilitiesAsBits(OsConstants.CAP_BLOCK_SUSPEND);
}
String args[] = {
"--setuid=1000",
"--setgid=1000",
"--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1023,1032,3001,3002,3003,3006,3007,3009,3010",
"--capabilities=" + capabilities + "," + capabilities,
"--nice-name=system_server",
"--runtime-args",
"com.android.server.SystemServer",
}; // 启动参数，进行权限的设置
ZygoteConnection.Arguments parsedArgs = null;
int pid;
try {
parsedArgs = new ZygoteConnection.Arguments(args);
// 解析启动参数，获取ZygoteConnection.Arguments对象
ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
// 设置参数对象的debugFLags，判断是否JDWP调试(默认是不调试的)
ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);
// 根据参数里的nice-name值获取SystemProperties对应的值，并保存到参数对象的invokeWith属性里，但这个属性默认是null
pid = Zygote.forkSystemServer(
parsedArgs.uid, parsedArgs.gid,
parsedArgs.gids,
parsedArgs.debugFlags,
null,
parsedArgs.permittedCapabilities,
parsedArgs.effectiveCapabilities); // fork子进程，返回子进程的pid
} catch (IllegalArgumentException ex) {
..
}
/* For child process */
if (pid == 0) { // fork完后，如果当前进程是子进程
if (hasSecondZygote(abiList)) { // 根据abiList考虑是否要进行第二次孵化
/*
这个是根据ro.product.cpu.abilist系统属性判断的，如果abiList不是这个系统属性的值，就要进行二次孵化
ro.product.cpu.abilist属性也包括了ro.product.cpu.abilist32属性，在Android-X86系统里，它们的值是
ro.product.cpu.abilist=x86,armeabi-v7a,armeabi
ro.product.cpu.abilist32=x86,armeabi-v7a,armeabi
*/
waitForSecondaryZygote(socketName); // 是的话，等待进行下一次孵化
}
zygoteServer.closeServerSocket(); // 不用的话，关闭套接字
handleSystemServerProcess(parsedArgs); // 而后继续SystemServer启动
}
return true;
}
解释都在注释里，如果fork完子进程，而且当前在子进程里，就进入下一步：handleSystemServerProcess()。这个子进程，就是SystemServer进程
ZygoteInit.handleSystemServerProcess()
由上文可知，这个方法是在SystemServer进程里被执行的，所以下面就是关于SystemServer如何被启动的内容了
private static void handleSystemServerProcess(
ZygoteConnection.Arguments parsedArgs)
throws Zygote.MethodAndArgsCaller {
// set umask to 0077 so new files and directories will default to owner-only permissions.
Os.umask(S_IRWXG | S_IRWXO);
if (parsedArgs.niceName != null) {
Process.setArgV0(parsedArgs.niceName);
// 设置进程的参数一为启动参数里的niceName(也就是SystemServer)
}
final String systemServerClasspath = Os.getenv("SYSTEMSERVERCLASSPATH");
// 获取环境变量SYSTEMSERVERCLASSPATH的值
if (systemServerClasspath != null) {
performSystemServerDexOpt(systemServerClasspath);
// 执行SystemServer的dex优化
boolean profileSystemServer = SystemProperties.getBoolean(
"dalvik.vm.profilesystemserver", false);
if (profileSystemServer && (Build.IS_USERDEBUG || Build.IS_ENG)) {
// 是否进行SystemServer性能优化
try {
File profileDir = Environment.getDataProfilesDePackageDirectory(
Process.SYSTEM_UID, "system_server");
File profile = new File(profileDir, "primary.prof");
profile.getParentFile().mkdirs();
profile.createNewFile();
String[] codePaths = systemServerClasspath.split(":");
VMRuntime.registerAppInfo(profile.getPath(), codePaths);
} catch (Exception e) {
..
}
}
}
if (parsedArgs.invokeWith != null) {
// 正常情况invokeWith为null
....
} else {
ClassLoader cl = null;
if (systemServerClasspath != null) {
// 获取path的classLoader，这个classLoader用来加载SystemServer类
cl = createPathClassLoader(systemServerClasspath, parsedArgs.targetSdkVersion);
Thread.currentThread().setContextClassLoader(cl);
// 设置此线程的上下文classLoader
}
ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
}
/* should never reach here */
}获取完SystemServer的classLoader后，调用zygoteInit()方法进行下一步初始化
ZygoteInit.zygoteInit()方法
public static final void zygoteInit(int targetSdkVersion, String[] argv,
ClassLoader classLoader) throws Zygote.MethodAndArgsCaller {
.. // 日志
RuntimeInit.redirectLogStreams(); // 把标准输出和标准错误重定向给log.i和log.e
RuntimeInit.commonInit(); // 针对日志和异常处理进行初始化
ZygoteInit.nativeZygoteInit(); // zygote初始化
RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
}又是一系列的初始化操作，之后进入RuntimeInit.applicationInit()方法，此方法代码如下
protected static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
throws Zygote.MethodAndArgsCaller {
nativeSetExitWithoutCleanup(true);
VMRuntime.getRuntime().setTargetHeapUtilization(0.75f); // 设置内存最大利用率
VMRuntime.getRuntime().setTargetSdkVersion(targetSdkVersion); // 设置sdk版本
final Arguments args;
try {
args = new Arguments(argv); // main()方法需要的参数
} catch (IllegalArgumentException ex) {
.. // 异常
}
..
invokeStaticMain(args.startClass, args.startArgs, classLoader);
}设置内存利用率和sdk版本，并且解析完参数后，调用invoteStaticMain()方法，调用main()，此方法代码如下
private static void invokeStaticMain(String className, String[] argv, ClassLoader classLoader)
throws Zygote.MethodAndArgsCaller {
Class cl;
try {
cl = Class.forName(className, true, classLoader); // 反射获取SystemServer类
} catch (ClassNotFoundException ex) {
.. // 异常
}
Method m;
try {
m = cl.getMethod("main", new Class[] { String[].class }); // 获取main()方法
} catch (Exception ex) {
..
}
int modifiers = m.getModifiers(); // 获取main()方法的访问修饰符
if (! (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))) {
.. // 如果不是静态公有的，就抛出异常
}
// 正常情况会抛出这个异常，这个异常在ZygoteInit.main()方法中被捕捉
throw new Zygote.MethodAndArgsCaller(m, argv);
}正常情况下，这段代码抛出Zygote.MethodAndArgsCaller异常，并携带main()方法和方法参数，它在ZygoteInit.main()方法中捕获后(可以回去看看ZygoteInit.main())，会调用这个异常的run()方法，run()方法代码如下
public void run() {
try {
mMethod.invoke(null, new Object[] { mArgs });
} catch (Exception ex) {
..
}
}执行SystemServer的main()方法，从而开始SystemServer的启动流程
结语
关于Zygote进程的启动过程就是如此。总结一下：
进行一系列初始化(包括系统资源，openGL，webView等)后，fork一个SystemServer进程，通过抛出异常的方式开始SystemServer的主函数的执行，fork之后的zygote自己则进入等待套接字连接的死循环。
源码选自Android8.0