概述

在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.cpp

int main(int argc, char* const argv[]){
    ...
    while (i < argc) {
        const char* arg = argv[i++];
        if (strcmp(arg, "--zygote") == 0) {// 注释1
            // 如果当前运行在 Zygote 进程中，则将 zygote 设置为 true
            zygote = true;// 注释2
            // 对于64位系统nice_name为zygote64; 32位系统为zygote
            niceName = ZYGOTE_NICE_NAME;
        } else if (strcmp(arg, "--start-system-server") == 0) {// 注释3
            // 如果当前运行在 SystemServer 进程中，则将 startSystemServer 设置为 true
            startSystemServer = 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_process
        runtime.setArgv0(niceName.string(), true /* setProcName */);
    }

    if (zygote) {// 注释5
        // 如果运行在Zygote进程中，则加载ZygoteInit
        runtime.start("com.android.internal.os.ZygoteInit", args, zygote);// 注释6
    } else if (className) {
        //如果是application启动模式，则加载RuntimeInit
        runtime.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.cpp

void 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) {//2
        ALOGE("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.Zygoteinit
    classNameStr = 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");//6
        if (startMeth == NULL) {
            ALOGE("JavaVM unable to find main() in '%s'\n", className);
            /* keep going */
        } else {
            // 通过JNI调用Zygoteinit的main 方法
            env->CallStaticVoidMethod(startClass, startMeth, strArray);

#if 0
            if (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.java

public static void main(String argv[]) {
    // 1. 创建ZygoteServer
    ZygoteServer 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-server
                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)) {
                zygoteSocketName = argv[i].substring(SOCKET_NAME_ARG.length());
            } else {
                throw new RuntimeException("Unknown command line argument: " + argv[i]);
            }        
        }
        // 根据传入socket name来决定是创建socket还是zygote_secondary
        final boolean isPrimaryZygote = zygoteSocketName.equals(Zygote.PRIMARY_SOCKET_NAME);
        ...
        // 在第一次zygote启动时，enableLazyPreload为false，执行preload
        if (!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);
            // 启动SystemServer
            if (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等library
    preloadSharedLibraries();
    // 用于初始化文字资源
    preloadTextResources();
    // 用于初始化webview
    WebViewFactory.prepareWebViewInZygote();
    // 预加载完成
    endPreload();
    warmUpJcaProviders();
    sPreloadComplete = true;
}

详解2：ZygoteServer()

frameworks/base/core/java/com/android/internal/os/ZygoteServer.java

private LocalServerSocket mZygoteSocket;

private LocalServerSocket mUsapPoolSocket;

ZygoteServer(boolean isPrimaryZygote) {
        mUsapPoolEventFD = Zygote.getUsapPoolEventFD();

        if (isPrimaryZygote) {
            // 创建socket，并获取socket对象，socketname： zygote
            mZygoteSocket = Zygote.createManagedSocketFromInitSocket(Zygote.PRIMARY_SOCKET_NAME);
            // 创建socket，并获取socket对象，socketname：usap_pool_primary
            mUsapPoolSocket =
                    Zygote.createManagedSocketFromInitSocket(
                            Zygote.USAP_POOL_PRIMARY_SOCKET_NAME);
        } else {
           // 创建socket，并获取socket对象，socketname：zygote_secondary
            mZygoteSocket = Zygote.createManagedSocketFromInitSocket(Zygote.SECONDARY_SOCKET_NAME);
            // 创建socket，并获取socket对象，socketname：usap_pool_secondary
            mUsapPoolSocket =
                    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.java

private 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.java

Runnable 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 socket

                    try {
                        //有socket连接，创建ZygoteConnection对象,并添加到fds
                        ZygoteConnection 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进程。