当前位置：首页 > news >正文

Framework学习之旅：Zygote进程

news 2025/12/27 3:05:12

概述

在Android系统中，DVM(Dalvik 虚拟机和ART、应用程序进程以及运行系统的关键服务SystemServer进程都是由Zygote进程来创建的。通过fork（复制进程）的形式来创建应用程进程和SystemServer进程，由于Zygote进程在启动时会创建DVM或者ART，因此通过 fork而创建的应用程序进程和SystemServer进程可以在内部获取DVM或者ART实例副本。

Zygote进程是init进程启动时创建的，Zygote进程的名称并不是叫zygote，而是叫app_process，这个名称是在Android.mk中定义的，Zygote进程启动后，Linux 系统下的petri 系统会调用app_process ，将其名称换成了“zygote ”。

Zygote启动脚本

init进程启动后，会解析init.rc文件，然后创建和加载service字段指定的进程。在init.rc 文件中采用了Import类型语句来引人Zygote启动脚本，这些启动脚本都是由Android初始化语言来编写的：

import/init.${ro.zygote}.rc

init.rc不会直接引入一个固定的文件，而是根据属性ro.zygote的内容来引入不同的文件。

Zygote有32位和64位的区别，所以在这里用ro.zygote属性来控制使用不同的Zygote启动脚本，从而也就启动了不同版本的Zygote进程，ro.zygote属性的取值有以下4种:

init.zygote32.rc
init.zygote32_64.rc
init.zygote64.rc
init.zygote64_32.rc

这些Zygote启动脚本都放在system/core/rootdir目录中。现在的主流厂家基本使用zygote64_32，因此，我们的rc文件为 init.zygote64_32.rc。

Zygote 进程启动过程

app_main.cpp的main函数

init进程启动Zygote时主要是调用app_main.cpp的main函数中的AppRuntime的start 方法来启动Zygote进程的，先从app_ main.cpp的main函数开始分析：

/frameworks/base/cmds/app_process/app_main.cppint main(int argc, char* const argv[]){...while (i < argc) {const char* arg = argv[i++];if (strcmp(arg, "--zygote") == 0) {// 注释1// 如果当前运行在 Zygote 进程中，则将 zygote 设置为 truezygote = true;// 注释2// 对于64位系统nice_name为zygote64; 32位系统为zygoteniceName = ZYGOTE_NICE_NAME;} else if (strcmp(arg, "--start-system-server") == 0) {// 注释3// 如果当前运行在 SystemServer 进程中，则将 startSystemServer 设置为 truestartSystemServer = true;// 注释4} else if (strcmp(arg, "--application") == 0) {//启动进入独立的程序模式application = true;} else if (strncmp(arg, "--nice-name=", 12) == 0) {//niceName 为当前进程别名，区别abi型号niceName.setTo(arg + 12);} else if (strncmp(arg, "--", 2) != 0) {className.setTo(arg);break;} else {--i;break;}}...if (!niceName.isEmpty()) {// 设置昵称zygote\zygote64，之前的名称是app_processruntime.setArgv0(niceName.string(), true /* setProcName */);}if (zygote) {// 注释5// 如果运行在Zygote进程中，则加载ZygoteInitruntime.start("com.android.internal.os.ZygoteInit", args, zygote);// 注释6} else if (className) {//如果是application启动模式，则加载RuntimeInitruntime.start("com.android.internal.os.RuntimeInit", args, zygote);} else {//没有指定类名或zygote，参数错误fprintf(stderr, "Error: no class name or --zygote supplied.\n");app_usage();LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");}
}

Zygote进程都是通过fork自身来创建子进程的，这样Zygote进程以及它的子进程都可以进入app_ main.cpp的main函数，因此main函数中为了区分当前运行在哪个进程中，会在注释1处判断参数arg中是否包含了–zygote，如果包含了则说明main函数是运行在Zygote 进程中的并在注释2处将zygote置为ture。在注释3处判断参数arg 中是否包含了“ start-system server”，如果包含了则说明main函数是运行在SystemServer进程中的并在注释4 处将startSystemServer设置为true。在注释5处，如果zygote为true，就说明当前运行在 Zygote 进程中，就会调用注释6处的AppRuntime的start函数，来加载虚拟机并进入JAVA世界。

frameworks/base/core/jni/AndroidRuntime.cppvoid AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{.../* start the virtual machine */JniInvocation jni_invocation;jni_invocation.Init(NULL);JNIEnv* env;// 启动Java虚拟机if (startVm(&mJavaVM, &env, zygote, primary_zygote) != 0) {return;}onVmCreated(env);// 为Java虚拟机注册JNI方法if (startReg(env) < 0) {//2ALOGE("Unable to register all android natives\n");return;}jclass stringClass;jobjectArray strArray;jstring classNameStr;stringClass = env->FindClass("java/lang/String");assert(stringClass != NULL);strArray = env->NewObjectArray(options.size() + 1, stringClass, NULL);assert(strArray != NULL);//从app_main的main函数得知className为com.android.internal.os.ZygoteinitclassNameStr = env->NewStringUTF(className);assert(classNameStr != NULL);env->SetObjectArrayElement(strArray, 0, classNameStr);for (size_t i = 0; i < options.size(); ++i) {jstring optionsStr = env->NewStringUTF(options.itemAt(i).string());assert(optionsStr != NULL);env->SetObjectArrayElement(strArray, i + 1, optionsStr);}// classNarne “.”替换为“/”char* slashClassName = toSlashClassName(className != NULL ? className : "");//找到Zygoteinit类jclass startClass = env->FindClass(slashClassName);if (startClass == NULL) {ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);/* keep going */} else {// 找到ZygoteInit的main方法jmethodID startMeth = env->GetStaticMethodID(startClass, "main","([Ljava/lang/String;)V");//6if (startMeth == NULL) {ALOGE("JavaVM unable to find main() in '%s'\n", className);/* keep going */} else {// 通过JNI调用Zygoteinit的main 方法env->CallStaticVoidMethod(startClass, startMeth, strArray);#if 0if (env->ExceptionCheck())threadExitUncaughtException(env);
#endif}}//释放相应对象的内存空间free(slashClassName);...
}

从以上代码可以看出，通过JNI调用Zygotelnit的main方法。因为Zygotelnit的main方法是由Java语言编写的，当前的运行逻辑在Native中，这就需要通过JNI调用Java。这样Zygote就从Native进入了Java框架层。start()函数主要做了三件事情：1.调用startVm函数开启虚拟机。2.调用startReg注册JNI方法。3.使用JNI把Zygote进程启动起来。

ZygoteInit的main函数

通过JNI调用ZygoteInit的main函数后，Zygote便进入了Java框架层，此前没有任何代码进入过Java框架层，换句换说Zygote开创了Java框架层。

frameworks/base/core/java/com/android/internal/os/ZygoteInit.javapublic static void main(String argv[]) {// 1. 创建ZygoteServerZygoteServer zygoteServer = null;// 调用native函数，确保当前没有其它线程在运行ZygoteHooks.startZygoteNoThreadCreation(); try {// 设置pid为0，Zygote进入自己的进程Os.setpgid(0, 0);} catch (ErrnoException ex) {throw new RuntimeException("Failed to setpgid(0,0)", ex);}Runnable caller;try{...boolean startSystemServer = false;String zygoteSocketName = "zygote";String abiList = null;boolean enableLazyPreload = false;// 2. 解析app_main.cpp - start()传入的参数for (int i = 1; i < argv.length; i++) {if ("start-system-server".equals(argv[i])) {//启动zygote时，才会传入参数：start-system-serverstartSystemServer = 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)) {zygoteSocketName = argv[i].substring(SOCKET_NAME_ARG.length());} else {throw new RuntimeException("Unknown command line argument: " + argv[i]);}        }// 根据传入socket name来决定是创建socket还是zygote_secondaryfinal boolean isPrimaryZygote = zygoteSocketName.equals(Zygote.PRIMARY_SOCKET_NAME);...// 在第一次zygote启动时，enableLazyPreload为false，执行preloadif (!enableLazyPreload) {bootTimingsTraceLog.traceBegin("ZygotePreload");EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,SystemClock.uptimeMillis());// 3.预加载类和资源(详解下文1)             preload(bootTimingsTraceLog);EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,SystemClock.uptimeMillis());bootTimingsTraceLog.traceEnd(); // ZygotePreload}...// 4.调用ZygoteServer构造函数，创建socket.(详解下文2)   zygoteServer = new ZygoteServer(isPrimaryZygote);if (startSystemServer) {//5.fork出systemServer(详解下文3)   Runnable r = forkSystemServer(abiList, zygoteSocketName, zygoteServer);// 启动SystemServerif (r != null) {r.run();// 调用SystemServer 的main 方法return;}} //6. zygote进程进入无限循环，等待AMS请求(详解下文4)   caller = zygoteServer.runSelectLoop(abiList);}catch (Throwable ex) {Log.e(TAG, "System zygote died with exception", ex);throw ex;} finally {if (zygoteServer != null) {zygoteServer.closeServerSocket();}}// 7.在子进程中退出了选择循环。继续执行命令if (caller != null) {caller.run();}
}

Zygotelnit的main方法主要做了4件事：1.创建一个Server端的Socket。2.预加载类和资源。3. 启动SystemServer进程。 4.等待AMS请求创建新的应用程序进程。

详解1：preload()

预加载

在Zygote进程启动的时候就加载，这样系统只在zygote执行一次加载操作，所有APP用到该资源不需要再重新加载，减少资源加载时间，加快了应用启动速度，一般情况下，系统中App共享的资源会被列为预加载资源。

Zygote fork子进程时，根据fork的copy-on-write机制可知，有些类如果不做改变，甚至都不用复制，子进程可以和父进程共享这部分数据，从而省去不少内存的占用。

预加载的原理

Zygote进程启动后将资源读取出来，保存到Resources一个全局静态变量中，下次读取系统资源的时候优先从静态变量中查找。

源码

static void preload(TimingsTraceLog bootTimingsTraceLog) {...// 获取字符集转换资源等beginPreload();// 预加载类的列表preloadClasses();cacheNonBootClasspathClassLoaders();// 加载图片、颜色等资源文件，部分定义在 /frameworks/base/core/res/res/values/arrays.xml中preloadResources();nativePreloadAppProcessHALs();maybePreloadGraphicsDriver();// 加载 android、compiler_rt、jnigraphics等librarypreloadSharedLibraries();// 用于初始化文字资源preloadTextResources();// 用于初始化webviewWebViewFactory.prepareWebViewInZygote();// 预加载完成endPreload();warmUpJcaProviders();sPreloadComplete = true;
}

详解2：ZygoteServer()

frameworks/base/core/java/com/android/internal/os/ZygoteServer.javaprivate LocalServerSocket mZygoteSocket;private LocalServerSocket mUsapPoolSocket;ZygoteServer(boolean isPrimaryZygote) {mUsapPoolEventFD = Zygote.getUsapPoolEventFD();if (isPrimaryZygote) {// 创建socket，并获取socket对象，socketname： zygotemZygoteSocket = Zygote.createManagedSocketFromInitSocket(Zygote.PRIMARY_SOCKET_NAME);// 创建socket，并获取socket对象，socketname：usap_pool_primarymUsapPoolSocket =Zygote.createManagedSocketFromInitSocket(Zygote.USAP_POOL_PRIMARY_SOCKET_NAME);} else {// 创建socket，并获取socket对象，socketname：zygote_secondarymZygoteSocket = Zygote.createManagedSocketFromInitSocket(Zygote.SECONDARY_SOCKET_NAME);// 创建socket，并获取socket对象，socketname：usap_pool_secondarymUsapPoolSocket =Zygote.createManagedSocketFromInitSocket(Zygote.USAP_POOL_SECONDARY_SOCKET_NAME);}mUsapPoolSupported = true;fetchUsapPoolPolicyProps();
}frameworks/base/core/java/com/android/internal/os/Zygote.java
static LocalServerSocket createManagedSocketFromInitSocket(String socketName) {int fileDesc;final String fullSocketName = ANDROID_SOCKET_PREFIX + socketName;try {// 在进程被创建时，就会创建对应的文件描述符，并加入到环境变量中,并取出对应的环境变量String env = System.getenv(fullSocketName);fileDesc = Integer.parseInt(env);} catch (RuntimeException ex) {throw new RuntimeException("Socket unset or invalid: " + fullSocketName, ex);}try {FileDescriptor fd = new FileDescriptor();// 获取zygote socket的文件描述符fd.setInt$(fileDesc);return new LocalServerSocket(fd);// 创建Socket的本地服务端} catch (IOException ex) {throw new RuntimeException("Error building socket from file descriptor: " + fileDesc, ex);}}

ZygoteServer 构造函数初始化时，根据传入的参数，利用LocalServerSocket创建了4个本地服务端的socket，用来建立连接，分别是：zygote、usap_pool_primary、zygote_secondary、usap_pool_secondary。

详解3：forkSystemServer

frameworks/base/core/java/com/android/internal/os/ZygoteInit.javaprivate static Runnable forkSystemServer(String abiList, String socketName, ZygoteServer zygoteServer) {...//来创建args数组，这个数组用来保存启动SystemServer 的启动参数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,3011","--capabilities=" + capabilities + "," + capabilities,"--nice-name=system_server","--runtime-args","--target-sdk-version=" + VMRuntime.SDK_VERSION_CUR_DEVELOPMENT,"com.android.server.SystemServer",};ZygoteArguments parsedArgs = null;  int pid;try {//将args数组封装成Arguments对象，并供下面的SystemServer 函数调用parsedArgs = new ZygoteArguments(args);Zygote.applyDebuggerSystemProperty(parsedArgs);Zygote.applyInvokeWithSystemProperty(parsedArgs);if (Zygote.nativeSupportsTaggedPointers()) {/* Enable pointer tagging in the system server. Hardware support for this is present* in all ARMv8 CPUs. */parsedArgs.mRuntimeFlags |= Zygote.MEMORY_TAG_LEVEL_TBI;}/* Enable gwp-asan on the system server with a small probability. This is the same* policy as applied to native processes and system apps. */parsedArgs.mRuntimeFlags |= Zygote.GWP_ASAN_LEVEL_LOTTERY;if (shouldProfileSystemServer()) {parsedArgs.mRuntimeFlags |= Zygote.PROFILE_SYSTEM_SERVER;}// 创建一个子进程，也就是 SystemServer 进程pid = Zygote.forkSystemServer(parsedArgs.mUid, parsedArgs.mGid,parsedArgs.mGids,parsedArgs.mRuntimeFlags,null,parsedArgs.mPermittedCapabilities,parsedArgs.mEffectiveCapabilities);} catch (IllegalArgumentException ex) {throw new RuntimeException(ex);}// 当前代码逻辑运行在子进程system_server中if (pid == 0) {// 处理32_64和64_32的情况if (hasSecondZygote(abiList)) {// /需要等待第二个Zygote创建完成waitForSecondaryZygote(socketName);}// 关闭连接zygoteServer.closeServerSocket();// 处理 SystemServer进程return handleSystemServerProcess(parsedArgs);}return null;
}

调用Zygote的forkSystemServer方法，其内部会调用nativeForkSystemServer这个Native方法，nativeForkSystemServer方法最终会通过fork函数在当前进程创建一个子进程，也就是SystemServer进程，如果forkSystemServer方法返回的pid的值为0，就表示当前的代码运行在新创建的子进程中。

详解4：runSelectLoop

frameworks/base/core/java/com/android/internal/os/ZygoteServer.javaRunnable runSelectLoop(String abiList) {ArrayList<FileDescriptor> socketFDs = new ArrayList<>();ArrayList<ZygoteConnection> peers = new ArrayList<>();// 该Socket的fd字段的值并添加到socketFDs列表socketFDs.add(mZygoteSocket.getFileDescriptor());// 无限循环等待AMS的请求while (true) {...int pollReturnValue;try {// 等待事件到来pollReturnValue = Os.poll(pollFDs,pollTimeoutMs);} catch (ErrnoException ex) {throw new RuntimeException("poll failed", ex);}... // 倒序处理，即优先处理已建立链接的信息，后处理新建链接的请求while (--pollIndex >= 0) {if (pollIndex == 0) {// 收到新的建立通信的请求，建立通信连接ZygoteConnection newPeer = acceptCommandPeer(abiList);peers.add(newPeer);//加入到peers和fds, 即下一次也开始监听 socketFDs.add(newPeer.getFileDescriptor());} else if (pollIndex < usapPoolEventFDIndex) {// Session socket accepted from the Zygote server sockettry {//有socket连接，创建ZygoteConnection对象,并添加到fdsZygoteConnection connection = peers.get(pollIndex);final Runnable command = connection.processOneCommand(this);}    }...}}

Zygote进程启动总结

创建AppRuntime并调用其start方法，启动Zygote进程。
创建Java虚拟机并为Java虚拟机注册JNI方法。
通过JNI调用Zygotelnit的main函数进入Zygote的Java框架层。
通过ZygoteServer创建服务端Socket，预加载类和资源，并通过runSelectLoop方法等待AMS的请求来创建新的应用程序进程。
启动SystemServer进程。

时序图

概述