0、引言

        AndROId的底层内核是基于Linux构建而成，是在Native世界，而Android上层的应用是隶属Java世界。那么在Android系统启动过程中，系统是如何从Native孵化出Java世界的呢F1f;这便是这篇文章的主角Zygote的主要职责。

        本文所选Android系统版本是9.0 Pie，文中所有代码片段路径在代码块第一行已经标注。文章的目的是记录自己的学习历程与心得，不做商用或盈利，凡是学习过程中学习或引用过的大佬博文或著作都会尽力标注，在此感谢各位前辈的不吝分享。本文借鉴如下：

• 《Android系统启动-zygote篇》—— 袁辉辉
• 《Android系统进程Zygote启动过程的源代码分析》—— 罗升阳
• 《[深入理解Android卷一全文-第四章]深入理解zygote》 —— 邓平凡
• 《Android10.0系统启动之Zygote进程-[Android取经之路]》—— IngresGe

---

2、Welcome To Java

        在上篇博文《Zygote——Android系统中java世界的受精卵（一、C/C++中的Zygote）》中，我们分析了，C/C++世界Zygote相关的启动代码，在结尾处，终于在ZygoteinIT.main()函数执行时，进入到了Java世界。所以这边文章就接着main函数往下看，追踪Java世界中Zygote相关的内容，;main()函数的代码依旧是分割开来解析 。

  2.1、准备工作

// pieframeworksbasecorejavacomandroidinternalosZygoteInit.java
public static void main(String[] argv) {
        ZygoteServer zygoteServer = null;
        //pielibcoredalviksrcmainjavadalvikSystemZygoteHooks.java
        ZygoteHooks.startZygoteNoThreadCreation();    //调用native函数，功能是确保此时没有其他线程启动
        try {
            Os.setpgid(0, 0);                         //设置pid
        } catch (ErrnoException ex) {
            throw new RuntimeException("Failed to setpgid(0,0)", ex);
        }

        Runnable caller;
        try {
            final long startTime = Systemclock.elapsedRealtime();    //系统启动到现在的时间，包含设备深度休眠的时间
            final boolean isRuntimeRestarted = "1".equals( 
                    SystemPRoPErties.get("sys.boot_completed"));     //该属性值在设备物理重启时为空，reboot重启后为1 
            String bootTimeTag = Process.is64Bit() ? "Zygote64Timing" : "Zygote32Timing";    //设置boot时间打印TAG
            //pieframeworksbasecorejavaandroidutilTimingsTraceLOG.java
            TimingsTraceLog bootTimingsTraceLog = new 
                TimingsTraceLog(bootTimeTag,Trace.TRACE_TAG_DALVIK); //通过systrace来追踪
            bootTimingsTraceLog.traceBegin("ZygoteInit");            //追踪开始，每个traceBegin()对应一个traceEnd()
            //使能DDMS(Dalvik Debug Monitor Server),注册所有已知的Java VM的处理块的监听器。
            //线程监听、内存监听、native堆内存监听、debug模式监听…
            RuntimeInit.preForkInit();    

            boolean startSystemServer = false;
            String zygoteSocketName = "zygote";
            String abiList = null;
            boolean enableLazyPreload = false;
            for (int i = 1; i < argv.length; i++) {
                if ("start-system-server".equals(argv[i])) {         //读取"start-system-server"参数
                    startSystemServer = true;
                //ro.zygote属性值为zygote64_32或zygote64_32时，会存在另外一个进程zygote_secondary，
                //zygote_secondary -Xzygote /system/bin --zygote --socket-name=zygote_secondary --enable-lazy-preload
                } else if ("--enable-lazy-preload".equals(argv[i])) {
                    enableLazyPreload = true;
                } else if (argv[i].startsWith(ABI_LIST_ARG)) {       //读取"--abi-list"参数
                    abiList = argv[i].substring(ABI_LIST_ARG.length());
                } else if (argv[i].startsWith(SOCKET_NAME_ARG)) {    //读取"--socket-name"参数
                    zygoteSocketName = argv[i].substring(SOCKET_NAME_ARG.length());
                } else {
                    throw new RuntimeException("Unknown command line argument: " + argv[i]);
                }
            }
            // Primary_SOCKET_NAME = "zygote"
            final boolean isPrimaryZygote = zygoteSocketName.equals(Zygote.PRIMARY_SOCKET_NAME);
            if (!isRuntimeRestarted) {
                if (isPrimaryZygote) {
                    FrameworkStatsLog.write(FrameworkStatsLog.BOOT_TIME_EVENT_ELAPSED_TIME_REPORTED,
                            BOOT_TIME_EVENT_ELAPSED_TIME__EVENT__ZYGOTE_INIT_START,
                            startTime);    //FrameworkStatsLog.java == statslog-framework-java-gen
                //SECONDARY_SOCKET_NAME = "zygote_secondary"
                } else if (zygoteSocketName.equals(Zygote.SECONDARY_SOCKET_NAME)) {    
                    FrameworkStatsLog.write(FrameworkStatsLog.BOOT_TIME_EVENT_ELAPSED_TIME_REPORTED,
                            BOOT_TIME_EVENT_ELAPSED_TIME__EVENT__SECONDARY_ZYGOTE_INIT_START,
                            startTime);
                }
            }

            if (abiList == null) {
                throw new RuntimeException("No ABI list supplied.");
            }
            …………

        这一部分主要是为后面的任务做准备工作：

•         禁止启动其他线程；
•         设置pid；
•         解析C/C++层传进来的参数argv；
•         设置相关日志追踪；

2.2、preload()

// pieframeworksbasecorejavacomandroidinternalosZygoteInit.java
   public static void main(String[] argv) {
        …………
        if (!enableLazyPreload) {
                bootTimingsTraceLog.traceBegin("ZygotePreload");
                EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,SystemClock.uptimeMillis());
                preload(bootTimingsTraceLog);    //预加载
                EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,SystemClock.uptimeMillis());
                bootTimingsTraceLog.traceEnd();
        }
   }

        这里的预加载是指将Java类、资源文件、图像资源等公共资源在zygote启动的时候就进行加载。这样一来，根据fork的copy-on-write机制，其他由zygote fork出来的进程在使用这些资源的时候就不需要再次加载了，而是直接使用。所以这是一种牺牲系统开机时间，来提高系统应用运行时的运行效率的手段。        

//pieframeworksbasecorejavacomandroidinternalosZygoteInit.java
    static void preload(TimingsTraceLog bootTimingsTraceLog) {
        Log.d(TAG, "begin preload");
        bootTimingsTraceLog.traceBegin("BeginPreload");
        beginPreload();                          //ZygoteHooks.onBeginPreload();
        bootTimingsTraceLog.traceEnd();          //BeginPreload
        bootTimingsTraceLog.traceBegin("PreloadClasses");
        preloadClasses();                        //预加载一些类
        bootTimingsTraceLog.traceEnd();          //PreloadClasses
        bootTimingsTraceLog.traceBegin("CacheNonBootClasspathClassLoaders");
        //加载一些应用程序使用但不能放入引导类路径的jar包库，这些库过去是引导类路径的一部分，但必须删除。
        //由于向后兼容性的原因，旧的系统应用程序仍然会使用它们，因此它们被缓存在这里以保持性能特征
        cacheNonBootClasspathClassLoaders();    
        bootTimingsTraceLog.traceEnd();          //CacheNonBootClasspathClassLoaders
        bootTimingsTraceLog.traceBegin("PreloadResources");
        preloadResources();                      //加载常用资源，以便它们可以跨进程共享,比如apk开发常用到的color、drawable等资源
        bootTimingsTraceLog.traceEnd();          //PreloadResources
        Trace.traceBegin(Trace.TRACE_TAG_DALVIK, "PreloadAppProcessHALs");
        nativePreloadAppProcessHALs();           //一些被大多数app进程加载的内容，需要通过HAL来添加（native）
        Trace.traceEnd(Trace.TRACE_TAG_DALVIK);
        Trace.traceBegin(Trace.TRACE_TAG_DALVIK, "PreloadGraphicsDriver");
        maybePreloadGraphicsDriver();            //根据属性ro.zygote.disable_gl_preload来判断是否禁止预加载图像驱动相关内容（native）
        Trace.traceEnd(Trace.TRACE_TAG_DALVIK);
        preloadSharedLibraries();                //加载几个共享库：libandroid.so、libcompiler_rt.so、libjnigraphics.so                          
        preloadTextResources();                  //启动字体缓存，设置Typeface              
        WebViewFactory.prepareWebViewInZygote(); //为了内存共享,WebViewFactory执行所有必须在zygote进程中运行的初始化
        endPreload();
        warmUpJcaProviders();                    //注册AndroidKeyStoreProvider并预热已经注册的provider
        Log.d(TAG, "end preload");

        sPreloadComplete = true;
    }

        其中的preloadClasses()函数是去加载目标设备目录树中，/system/etc/preloaded-classes这个文件中每行一个全限定名格式的类（#开头的注释行和空白行则自动跳过）。该文件是由文件frameworksbasetoolspreloadWritePreloadedClassFile.java自动生成，其对于哪些类需要预加载有明确的说明：

/*
* pieframeworksbasetoolspreloadWritePreloadedClassFile.java
* The set of classes to preload. We preload a class if:
* a) it's loaded in the bootclasspath (i.e., is a system class)                1、即系统类
* b) it takes > MIN_LOAD_TIME_MICROS = 1250 us to load, and                    2、加载时长超过1250ms的类
* c) it's loaded by more than one process, or it's loaded by anapplication     3、不止一个进程会去加载的类
*/

2.3、gcAnDFinalize()

//pieframeworksbasecorejavacomandroidinternalosZygoteInit.java
    public static void main(String[] argv) {
            …………
            bootTimingsTraceLog.traceBegin("PostZygoteInitGC");
            // 调用ZygoteHooks.gcAndFinalize()，通过runFinalizationSync()可以在没有HeapWorker线程的Zygote中调用finalizers，
            //以运行几个特殊的gc来尝试清理几代软可及和最终可及的对象，以及任何其他垃圾。
            gcAndFinalize();
            bootTimingsTraceLog.traceEnd(); // PostZygoteInitGC
            bootTimingsTraceLog.traceEnd(); // 对应bootTimingsTraceLog.traceBegin("ZygoteInit")   
            Zygote.initNativeState(isPrimaryZygote);    //初始化zygote的native状态（native方法）
            ZygoteHooks.stopZygoteNoThreadCreation();   //可以启动其他线程了，对应前面的ZygoteHooks.startZygoteNoThreadCreation();
            …………
    }

        gcAndFinalize()方法主要就是在预加载动作之后、后续从zygote fork其他进程的动作之前，进行的一次垃圾回收。这里需要补充看一下上面这个代码段中的Zygote.initNativeState()方法：

// pieframeworksbasecorejavacomandroidinternalosZygote.java
    static void initNativeState(boolean isPrimary) {
        nativeInitNativeState(isPrimary);
    }

// pieframeworksbasecorejnicom_android_internal_os_Zygote.cpp
static void com_android_internal_os_Zygote_nativeInitNativeState(JNIenv* env, jclass, jboolean is_primary) {
  gZygoteSocketFD = android_get_control_socket(is_primary ? "zygote" : "zygote_secondary");    //获取socket的句柄fd
  if (gZygoteSocketFD >= 0) {
    ALOGV("Zygote:zygoteSocketFD = %d", gZygoteSocketFD);
  } else {
    ALOGE("Unable to fetch Zygote socket file descriptor");
  }
  gUsapPoolSocketFD = android_get_control_socket(is_primary ? "usap_pool_primary" : "usap_pool_secondary");
  if (gUsapPoolSocketFD >= 0) {
    ALOGV("Zygote:usapPoolSocketFD = %d", gUsapPoolSocketFD);
  } else {
    ALOGE("Unable to fetch USAP pool socket file descriptor");
  }
  //创建套接字，该套接字将被用来发送未经请求的消息到system_server，该套接字将在派生子进程后被关闭
  initUnsolSocketToSystemServer();    

  gIsSecurityEnforced = security_getenforce();    //根据selinux策略，普通apk是禁止security_getenforce的，
  selinux_android_seapp_context_init();           //所以在zygote fork之前初始化并缓存该策略值

  //Zygote进程在fork每个子进程之前首先卸载根存储空间,因为Zygote进程不使用根存储空间，所以取消对其下面的挂载名称空间的共享。
  //每个fork的子进程(包括SystemServer)只挂载它们自己的根存储空间,在mountEmulatedStorage方法中不需要卸载存储操作。
  UnmountStorageOnInit(env);

  if (!SetTaskProfiles(0, {})) {    //加载必须的performance profile信息
    zygote::ZygoteFailure(env, "zygote", nullptr, "Zygote SetTaskProfiles failed");
  }
}

        该函数的功能概括来讲做了这四件事：

•         从环境变量中获取socket句柄fd；
•         初始化安全属性；
•         卸载适当的存储；
•         加载必要的性能概要信息；

        还有需要说明一下的是代码里出现的USAP(Unspecialized App Process)，是指在android高版本里提出来的一种zygote fork子进程的机制。通过prefork的方式提前创建好一批进程，当有应用启动时，直接将已经创建好的进程分配给它，从而省去了fork的动作，从而可以提升性能。详情参考《Android Framework | 一种新型的应用启动机制:USAP》。

2.4、 forkSystemServer()

        前面的三个小节做好准备工作后，下面就要开始做zygote比较重要的的一个任务了，那就是fork出system_server进程：

//pieframeworksbasecorejavacomandroidinternalosZygoteInit.java
    public static void main(String[] argv) {
            …………
            zygoteServer = new ZygoteServer(isPrimaryZygote);    //创建zygote的ServerSocket
            if (startSystemServer) {
                Runnable r = forkSystemServer(abiList, zygoteSocketName, zygoteServer);
                if (r != null) {    //{r == null} in the parent process, and {r != null} in the child process
                    r.run();    //通过反射机制执行SystemServer.java的main()函数
                    return;
                }
            }
            …………
    }

        这里先是通过ZygoteServer类的构造函数，去创建zygote的LocalServerSocket：

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

        if (isPrimaryZygote) {
            mZygoteSocket = Zygote.createManagedSocketFromInitSocket(Zygote.PRIMARY_SOCKET_NAME);
            mUsapPoolSocket = Zygote.createManagedSocketFromInitSocket(Zygote.USAP_POOL_PRIMARY_SOCKET_NAME);
        } else {
            mZygoteSocket =Zygote.createManagedSocketFromInitSocket(Zygote.SECONDARY_SOCKET_NAME);
            mUsapPoolSocket = Zygote.createManagedSocketFromInitSocket(Zygote.USAP_POOL_SECONDARY_SOCKET_NAME);
        }
        mUsapPoolSupported = true;
        fetchUsapPoolpolicyProps();    //TODO
    }

// pieframeworksbasecorejavacomandroidinternalosZygote.java
    static LocalServerSocket createManagedSocketFromInitSocket(String socketName) {
        int fileDesc;
        final String fullSocketName = ANDROID_SOCKET_PREFIX + socketName;    // "ANDROID_SOCKET_zygote"

        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();
            fd.setInt$(fileDesc);
            return new LocalServerSocket(fd);
        } catch (IOException ex) {
            throw new RuntimeException(
                "Error building socket from file descriptor: " + fileDesc, ex);
        }
    }

        可以看出createManagedSocketFromInitSocket()函数首先是根据socket默认前缀 "ANDROID_SOCKET_"和该socket名称"zygote"，拼接成环境变量的key = "ANDROID_SOCKET_zygote" ，然后以该key值从环境变量中获取目标socket的文件描述符fd。（这个环境变量的键值在init阶段解析init.zygote.rc、读取并启动zygote这个service下面的socket（socket zygote stream 660 root system），在目标设备创建/dev/socket/zygote 这个文件时，就已经以"ANDROID_SOCKET_zygote"为键，创建该socket的文件描述符fd为值，存储到环境变量中了。）这里获取到目标socket的文件描述符后，就用其创建了LocalServerSocket。

        以上这些准备好了之后，就要做forkSystemServer这个重要的动作了，鉴于该函数挺长，所以依然分割开来解析。

        2.4.1、参数准备

// pieframeworksbasecorejavacomandroidinternalosZygoteInit.java
private static Runnable forkSystemServer(String abiList, String socketName,
            ZygoteServer zygoteServer) {
        long capabilities = posixCapabilitiesAsBits(
                OsConstants.CAP_IPC_LOCK,
                OsConstants.CAP_KILL,
                OsConstants.CAP_NET_ADMIN,
                OsConstants.CAP_NET_BIND_SERVICE,
                OsConstants.CAP_NET_BROADCAST,
                OsConstants.CAP_NET_RAW,
                OsConstants.CAP_SYS_MODULE,
                OsConstants.CAP_SYS_NICE,
                OsConstants.CAP_SYS_PTRACE,
                OsConstants.CAP_SYS_TIME,
                OsConstants.CAP_SYS_TTY_config,
                OsConstants.CAP_WAKE_ALARM,
                OsConstants.CAP_BLOCK_SUSPEND
        );
        StructCapUserHeader header = new StructCapUserHeader(OsConstants._LINUX_CAPABILITY_VERSION_3, 0);
        StructCapUserData[] data;
        try {
            data = Os.capget(header);
        } catch (ErrnoException ex) {
            throw new RuntimeException("Failed to capget()", ex);
        }
        capabilities &amp;= ((long) data[0].effective) | (((long) data[1].effective) << 32);

        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",
        };
        …………
}

        这里主要做的工作就是为后面fork出system_server进程准备启动参数。首先是通过posixCapabilitiesAsBits()函数配置一个long类型的（POSIX capability）能力参数（说人话就是配置system_server进程可以拥有的能力或权限，即能做哪些事），然后和其他命令行参数一起组成启动system_server所需要传入的字符串数组类型的参数args。

        其中的OsConstants类位于pielibcorelunisrcmainjavaandroidsystemOsConstants.java中，这个类把CAP_KILL这些静态常量都设置为0，源码注释：A hack to avoid these constants being inlined by javac......because we want to initialize them at runtime.大概意思就是说，这样做是不想在静态编译（javac）的时候这些常量被内联进去，而是想借用native方法在运行时去初始化。具体操作就是在该Java类的静态块里面调用了一个native接口，该native接口在运行时才会通过GetStatiCFieldID()和SetStaticIntField()函数去给这些静态常量设置具体的值。该native方法位于pielibcorelunisrcmainnativeandroid_system_OsConstants.cpp中，而这些值的具体定义是在<linux/capability.h>中，而这个文件位于piebioniclibckerneluapilinuxcapability.h。这些原文件中对每个数值定义都有详细的说明注释，有兴趣可以看看这些注释。看明白这些数值的的定义范围，返回来就看得懂函数posixCapabilitiesAsBits()通过传入的不定参数，对system_server进程能力（Capabilities）的配置过程了：

/**
*kitkakframeworksbasecorejavacomandroidinternalosZygoteInit.java
* Gets the bit array representation of the provided list of POSIX capabilities.
*/
private static long posixCapabilitiesAsBits(int... capabilities) {
    long result = 0;
    for (int capability : capabilities) {
        if ((capability < 0) || (capability > OsConstants.CAP_LAST_CAP)) {
            throw new IllegalArgumentException(String.valueOf(capability));
        }
        result |= (1L << capability);
    }
    return result;
}

        其无非就是通过位操作，将目标long类型整数的二进制形式中，能力（Capabilities）使能所代表的位置为1而已。比如不定参数的第一个常量CAP_KILL的数值为5，则代码将long类型的1有符号左移五位，其他不同的数值也是类似左移不同的位数，最终通过 |= 操作整合出目标数值。

        2.4.2、参数解析与标识置位

// pieframeworksbasecorejavacomandroidinternalosZygoteInit.java
private static Runnable forkSystemServer(String abiList, String socketName,
            ZygoteServer zygoteServer) {
        …………
        ZygoteArguments parsedArgs;
        int pid;
        try {
            //将args存储到zygote命令缓冲区中，这个ZygoteCommandBuffer是一个用于Zygote命令的本机可访问的缓冲区。
            //设计支持重复fork的应用程序，而不干预内存分配，从而保持zygote内存尽可能稳定
            ZygoteCommandBuffer commandBuffer = new ZygoteCommandBuffer(args);
            try {   //单例模式解析参数
                parsedArgs = ZygoteArguments.getInstance(commandBuffer);
            } catch (EOFException e) {
                throw new AssertionError("Unexpected argument error for forking system server", e);
            }
            commandBuffer.close();    //及时释放本地资源，避免命令重复调用
            Zygote.applyDebuggerSystemProperty(parsedArgs);
            Zygote.applyInvokeWithSystemProperty(parsedArgs); //--invoke-with=？

            if (Zygote.nativeSupportsMemoryTagging()) {
                /* The system server has ASYNC MTE by default, in order to allow system services to specify 
                 * their own MTE level later, as you can't re-enable MTE once it's disabled. */
                String mode = SystemProperties.get("arm64.memtag.process.system_server", "async");
                if (mode.equals("async")) {
                    parsedArgs.mRuntimeFlags |= Zygote.MEMORY_TAG_LEVEL_ASYNC;
                } else if (mode.equals("sync")) {
                    parsedArgs.mRuntimeFlags |= Zygote.MEMORY_TAG_LEVEL_SYNC;
                } else if (!mode.equals("off")) {
                    // When we have an invalid memory tag level, keep the current level.
                    parsedArgs.mRuntimeFlags |= Zygote.nativeCurrentTaggingLevel();
                    Slog.e(TAG, "Unknown memory tag level for the system server: "" + mode + """);
                }
            } else 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;
            }
        …………   
}

        这里主要是先将2.4.1部分准备的参数args存储到ZygoteCommandBuffer这个命令缓冲区中，然后通过ZygoteArguments.getInstance()接口，获取单例模式的ZygoteArguments类的实例。之后ZygoteArguments类的构造函数调用parseArgs()函数对这些zygote命令参数进行解析，最后根据一些配置对参数解析出来的结果对象parsedArgs的mRuntimeFlags成员进行标识位置位。

       获取单例模式的ZygoteArguments的实例时，在构造函数中调用parseArgs()去解析参数的过程：

//pieframeworksbasecorejavacomandroidinternalosZygoteArguments.java
    private ZygoteArguments(ZygoteCommandBuffer args, int argCount)
            throws IllegalArgumentException, EOFException {
        parseArgs(args, argCount);
    }

    public static ZygoteArguments getInstance(ZygoteCommandBuffer args)
            throws IllegalArgumentException, EOFException {
        int argCount = args.getCount();
        return argCount == 0 ? null : new ZygoteArguments(args, argCount);
    }

        2.4.3、真正的fork动作

// pieframeworksbasecorejavacomandroidinternalosZygoteInit.java
    private static Runnable forkSystemServer(String abiList, String socketName,
            ZygoteServer zygoteServer) {
        …………
        int pid;
        try {
            …………
            pid = Zygote.forkSystemServer(
                    parsedArgs.mUid, parsedArgs.mGid,
                    parsedArgs.mGids,
                    parsedArgs.mRuntimeFlags,
                    null,
                    parsedArgs.mPermittedCapabilities,
                    parsedArgs.mEffectiveCapabilities);
        } catch (IllegalArgumentException ex) {
            throw new RuntimeException(ex);
        }
        …………
    }

         这里直接去找Zygote.forkSystemServer()方法：

//pieframeworksbasecorejavacomandroidinternalosZygote.java
    static int forkSystemServer(int uid, int gid, int[] gids, int runtimeFlags,
            int[][] rlimits, long permittedCapabilities, long effectiveCapabilities) {
        ZygoteHooks.preFork();    //停掉守护线程，停掉当前进程的所有的线程，zygote每次fork前调用

        int pid = nativeForkSystemServer(
                uid, gid, gids, runtimeFlags, rlimits,
                permittedCapabilities, effectiveCapabilities);

        Thread.currentThread().setPriority(Thread.NORM_PRIORITY);    //设置当前线程优先级
        
        //每次调用preFork()后，都会在子进程上调用postForkChild()，
        //并且都会在父进程和子进程上调用postForkCommon()，
        //子进程调用postForkCommon()在PostForkCommon()之后
        ZygoteHooks.postForkCommon();
        return pid;
    }

        这里做了fork前的准备后，主要就是通过jni去调用了nativeForkSystemServer()函数：

//pieframeworksbasecorejnicom_android_internal_os_Zygote.cpp
static jint com_android_internal_os_Zygote_nativeForkSystemServer(
        JNIEnv* env, jclass, uid_t uid, gid_t gid, jintArray gids,
        jint runtime_flags, jobjectArray rlimits, jlong permitted_capabilities,
        jlong effective_capabilities) {
  //初始化USAP相关的一个vector
  std::vector<int> fds_to_close(MakeUsapPipeReadFDVector()), fds_to_ignore(fds_to_close);
  fds_to_close.push_back(gUsapPoolSocketFD);

  if (gUsapPoolEventFD != -1) {
    fds_to_close.push_back(gUsapPoolEventFD);
    fds_to_ignore.push_back(gUsapPoolEventFD);
  }

  if (gSystemServerSocketFd != -1) {
      fds_to_close.push_back(gSystemServerSocketFd);
      fds_to_ignore.push_back(gSystemServerSocketFd);
  }

  pid_t pid = zygote::ForkCommon(env, true, fds_to_close, fds_to_ignore, true);    //fork动作
  if (pid == 0) {
      /在子进程中进行一些system_server相关配置，有兴趣的话去详细看看
      SpecializeCommon(env, uid, gid, gids, runtime_flags, rlimits,
                       permitted_capabilities, effective_capabilities,
                       MOUNT_EXTERNAL_DEFAULT, nullptr, nullptr, true, false, 
                       nullptr, nullptr, false, nullptr, false, false);
  } else if (pid > 0) {
      ALOGI("System server process %d has been created", pid);
      gSystemServerPid = pid;
      int status;
      //在父进程zygote中使用waitpid()函数以及WNOHANG这个选项，监控子进程的结束情况，
      //监控到system_server进程结束时，需要重启zygote。
      //waitpid()函数参考https://www.cnblogs.COM/zhaihongliangblogger/p/6367041.htML
      if (waitpid(pid, &status, WNOHANG) == pid) {
          ALOGE("System server process %d has died. Restarting Zygote!", pid);
          RuntimeAbort(env, __LINE__, "System server process has died. Restarting Zygote!");
      }

      if (UsePerAppMemcg()) {    //检测是否挂载了memcg
          if (!SetTaskProfiles(pid, std::vector<std::string>{"SystemMemoryProcess"})) {
              ALOGE("couldn't add process %d into system memcg group", pid);
          }
      }
  }
  return pid;
}

        这里重点就是通过ForkCommon()函数fork子进程，然后通过SpecializeCommon()函数对子进程做一些配置。这里主要来看一下ForkCommon()函数的fork过程：

// pieframeworksbasejnicom_android_internal_os_Zygote.cpp
pid_t zygote::ForkCommon(JNIEnv* env, bool is_system_server,
                         const std::vector<int>& fds_to_close,
                         const std::vector<int>& fds_to_ignore,
                         bool is_priority_fork,
                         bool purge) {
  SetSignalHandlers();    //为zygote管理子进程配置信号SIGCHLD/SIGHUP
  //指定ZygoteFailure函数，其用来向runtime报告致命错误
  auto fail_fn = std::bind(zygote::ZygoteFailure, env, is_system_server ? "system_server" : "zygote", nullptr, _1);

  //在fork期间临时阻塞SIGCHLD。SIGCHLD处理程序可能会记录日志，
  BlockSignal(SIGCHLD, fail_fn); //这将导致我们关闭的日志fd被重新打开。会导致失败，因为不允许列出fd
  __android_log_close();         //在开始计算文件描述符列表之前，关闭所有与日志记录相关的fd
  AStatsSocket_close();

  if (gOpenFdTable == nullptr) { //如果这是zygote的第一次fork，则创建一个打开的FD表，验证文件受支持的类型和允许列表
    gOpenFdTable = FileDescriptorTable::Create(fds_to_ignore, fail_fn);
  } else {    //如果不是，则检查打开的文件是否没有更改，不希望并且未来会禁止打开新的文件。
    gOpenFdTable->Restat(fds_to_ignore, fail_fn);    //目前的做法是，如果通过了上面的Create检测，则允许打开新的文件
  }
  android_fdsan_error_level fdsan_error_level = android_fdsan_get_error_level();

  if (purge) {           //清除未使用的本机内存，以减少与子进程的错误共享。通过减少与子进程共享的libc_malloc区域的大小，  
    mallopt(M_PURGE, 0); //当malloc在fork之后调整它所管理的每个页面上的元数据时，可以减少转换到私有脏状态的页面数量
  }

  pid_t pid = fork();    //核心的fork动作
  if (pid == 0) {        //子进程
    if (is_priority_fork) {
      setpriority(PRIO_PROCESS, 0, PROCESS_PRIORITY_MAX);
    } else {
      setpriority(PRIO_PROCESS, 0, PROCESS_PRIORITY_MIN);
    }

    PreApplicationInit();
    DetachDescriptors(env, fds_to_close, fail_fn);    //通过duP3()函数清除那些需要立即关闭的文件描述符
    ClearUsapTable();                                 //清除USAP进程表
    gOpenFdTable->ReopenOrDetach(fail_fn);            //重新打开所有剩余的打开的文件描述符，这样它们就不会通过fork与zygote共享
    android_fdsan_set_error_level(fdsan_error_level);
    gSystemServerSocketFd = -1;
  } else {               //父进程
    ALOGD("Forked child process %d", pid);
  }

  UnblockSignal(SIGCHLD, fail_fn);                    //fork结束后打开阻塞，对应上面的BlockSignal()
  return pid;
}

         2.4.4、fork后的扫尾工作

// pieframeworksbasecorejavacomandroidinternalosZygoteInit.java
    private static Runnable forkSystemServer(String abiList, String socketName,
            ZygoteServer zygoteServer) {
        …………
        //由于fork()函数完成任务后返回的位置不确定，如果在子进程中,fork函数返回0;
        //如果在父进程中，fork返回新创建子进程的进程ID
        if (pid == 0) {    
            if (hasSecondZygote(abiList)) {            //通过比较设备ABI列表和受精卵列表来确定这一点,
                waitForSecondaryZygote(socketName);    //如果这个受精卵支持该设备支持的所有abi，就不会有另一个受精卵
            }

            zygoteServer.closeServerSocket();    //fork出来的子进程中不会用到zygoteServer这个socket，所以要关掉
            return handleSystemServerProcess(parsedArgs);    //做一些fork system_server的扫尾工作
        }

        return null;
    }

         在上一小节的native fork动作结束返回后，这里需要通过handleSystemServerProcess()方法来做一些system_server进程的收尾动作：

// pieframeworksbasecorejavacomandroidinternalosZygoteInit.java
private static Runnable handleSystemServerProcess(ZygoteArguments parsedArgs) {
        Os.umask(S_IRWXG | S_IRWXO);    //进程权限设置为0077，这样新文件和目录将默认为所有者权限
        if (parsedArgs.mNiceName != null) {    //参数准备部分的"--nice-name=system_server"
            Process.setArgV0(parsedArgs.mNiceName);    //进程名设置为system_server
        }
        //环境变量SYSTEMSERVERCLASSPATH=/system/framework/services.jar:
        //                        /system/framework/ethernet-service.jar:
        //                        /system/framework/wifi-service.jar:…………
        final String systemServerClasspath = Os.getenv("SYSTEMSERVERCLASSPATH");
        if (systemServerClasspath != null) {
            if (shouldProfileSystemServer() && (Build.IS_USERDEBUG || Build.IS_ENG)) {
                try {
                    Log.d(TAG, "Preparing system server profile");
                    prepareSystemServerProfile(systemServerClasspath);    //debug或eng模式下准备system_server的profile文件
                } catch (Exception e) {
                    Log.wtf(TAG, "Failed to set up system server profile", e);
                }
            }
        }

        if (parsedArgs.mInvokeWith != null) {    //TODO
            String[] args = parsedArgs.mRemainingArgs;
            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.mInvokeWith, parsedArgs.mNiceName, parsedArgs.mTargetSdkVersion,
                                        VMRuntime.getCurrentInstructionSet(), null, args);
            throw new IllegalStateException("Unexpected return from WrapperInit.execApplication");
        } else {    //一般system_server走这个分支
            ClassLoader cl = getOrCreateSystemServerClassLoader(); //为system_server创建类加载器
            if (cl != null) {
                Thread.currentThread().setContextClassLoader(cl);  //为当前线程设置上下文类加载器
            }
            return ZygoteInit.zygoteInit(parsedArgs.mTargetSdkVersion, parsedArgs.mDisabledCompatChanges,
                                         parsedArgs.mRemainingArgs, cl);
        }
    }

        继续追踪ZygoteInit.zygoteInit() 方法：

// pieframeworksbasecorejavacomandroidinternalosZygoteInit.java
    public static Runnable zygoteInit(int targetSdkVersion, long[] disabledCompatChanges,
            String[] argv, ClassLoader classLoader) {
        if (RuntimeInit.DEBUG) {
            Slog.d(RuntimeInit.TAG, "RuntimeInit: Starting application from zygote");
        }

        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ZygoteInit");
        RuntimeInit.redirectLogStreams();    //将java的system.out和system.err log输出流重定向到AndroidPrintStream
        RuntimeInit.commonInit(); //设置log配置、通过persist.sys.timezone的属性值设置时区、设置默认的HTTP User-agent格式到http.agent属性    
        //通过JNI调用AndroidRuntime的成员gCurRuntime(即app_process.cpp中)的onZygoteInit()函数，
        ZygoteInit.nativeZygoteInit();     //主要完成创建binder的工作
        return RuntimeInit.applicationInit(targetSdkVersion, disabledCompatChanges, argv, classLoader);
    }

        追踪RuntimeInit.applicationInit()方法：

// pieframeworksbasecorejavacomandroidinternalosRuntimeInit.java
    protected static Runnable applicationInit(int targetSdkVersion, long[] disabledCompatChanges, String[] argv, ClassLoader classLoader) {
        …………
        //从前面准备的参数中解析出"com.android.server.SystemServer"赋值给args.startClass
        final Arguments args = new Arguments(argv);
        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);    //对应上面ZygoteInit的traceBegin()
        //有了类的全限定名，通过反射机制找到SystemServer.java的main()方法
        return findstaticMain(args.startClass, args.startArgs, classLoader);
    }


    protected static Runnable findStaticMain(String classname, String[] argv, ClassLoader classLoader) {
        …………    //省略通过反射机制寻找main方法的过程
        return new MethodAndArgsCaller(m, argv);
    }

    //将main方法封装到Runnable实例中返回，最终返回给2.4节一开始的Runnable r，然后通过r.run()执行该main方法
    static class MethodAndArgsCaller implements Runnable {
        private final Method mMethod;
        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) {
              …………
            }
        }
    }

        总结一下2.4.4小节主要做了：

1.         对fork出来的新进程的权限设定；
2.         进程命名为system_server；
3.         创建类加载器加载system_server的java类；
4.         通过反射机制找到SystemServer.java的main函数，并封装到Runnable r；
5.         方法return到2.4节一开始，通过r.run()执行该main方法，以启动SystsmServer；

2.5、runSelectLoop()

        zygote除了fork出system_server进程这个任务外，还有一个重要的任务，那就是接收AMS(ActivityManagerService)发来创建java层应用程序的请求，fork出一个个进程，并在新进程中执行该请求中相关应用程序的main方法。上层的一个个应用程序就是这样通过zygote创建而来，因为应用程序都是由zygote孕育而来，所以就不难理解zygote(受精卵)的名称的由来了。我们继续往下看看它是如何完成这一任务的：

// pieframeworksbasecorejavacomandroidinternalosZygoteInit.java
    public static void main(String[] argv) {
        …………
        Runnable caller;
        try {
            …………
            Log.i(TAG, "Accepting command socket connections");
            caller = zygoteServer.runSelectLoop(abiList);
        } catch (Throwable ex) {
            Log.e(TAG, "System zygote died with fatal exception", ex);
            throw ex;
        } finally {
            if (zygoteServer != null) {
                zygoteServer.closeServerSocket();    //zygote挂掉的时候关闭ServerSocket
            }
        }

        if (caller != null) {
            caller.run();
        }
    }

        runSelectLoop()方法冗长，有太多USAP相关的操作，我们这里省略相关内容，只看核心操作：

// pieframeworksbasecorejavacomandroidinternalosZygoteServer.java
Runnable runSelectLoop(String abiList) {
        ArrayList<FileDescriptor> socketFDs = new ArrayList<>();
        ArrayList<ZygoteConnection> peers = new ArrayList<>();
        socketFDs.add(mZygoteSocket.getFileDescriptor());    //先将server socket加入到这个socketFDs列表
        peers.add(null);

        while (true) {    //间隔时间持续轮询
            …………
            int[] usapPipeFDs = null;
            StructPollfd[] pollFDs;
            pollFDs = new StructPollfd[socketFDs.size()];    //每轮循环，都重新创建需要监听的pollFDs
            int pollIndex = 0;
            for (FileDescriptor socketFD : socketFDs) {
                pollFDs[pollIndex] = new StructPollfd();
                pollFDs[pollIndex].fd = socketFD;
                pollFDs[pollIndex].events = (short) POLLIN;    //关注poll事件到来
                ++pollIndex;
            }
            …………
            int pollTimeoutMs;//设置poll轮询时延间隔 
            int pollReturnValue;
            try {
                pollReturnValue = Os.poll(pollFDs, pollTimeoutMs);
            …………

            if (pollReturnValue == 0) {    …………
            } else {
                while (--pollIndex >= 0) {
                    if ((pollFDs[pollIndex].revents & POLLIN) == 0) {
                        continue;
                    }

                    if (pollIndex == 0) {    //server socket最先加入fds， 因此这里是server socket收到数据
                        ZygoteConnection newPeer = acceptCommandPeer(abiList);    //收到新的建立通信的请求，建立通信连接
                        peers.add(newPeer);  //加入到peers和fds, 即下一次也开始监听
                        socketFDs.add(newPeer.getFileDescriptor());
                    } else if (pollIndex < usapPoolEventFDIndex) {    //说明接收到AMS通过socket发送过来创建应用程序的请求
                        try {
                            //有socket连接时创建ZygoteConnection对象,并添加到pollFDs
                            ZygoteConnection connection = peers.get(pollIndex);
                            boolean multipleForksOK = !isUsapPoolEnabled()
                                    && ZygoteHooks.isIndefiniteThreadSuspensionSafe();
                            final Runnable command =
                                    connection.processCommand(this, multipleForksOK);    //完成创建子进程的请求
                            if (mIsForkChild) {
                                if (command == null) {
                                    throw new IllegalStateException("command == null");
                                }
                                return command;    //依然是提供Runnable接口，通过反射机制执行目标应用程序的main方法
                            } else {
                                if (command != null) {
                                    throw new IllegalStateException("command != null");
                                }
                                //处理完后，关闭socket连接，并从peers和socketFDs列表中移除
                                if (connection.isClosedByPeer()) {    
                                    connection.closeSocket();
                                    peers.remove(pollIndex);
                                    socketFDs.remove(pollIndex);
                                }
                            }
                        } catch (Exception e) {
                            …………
    }

        这里大概意思就是，循环间隔一段时间轮询连接socket消息，看是否有AMS客户端发过来创建应用程序的请求，有的话则通过pieframeworksbasecorejavacomandroidinternalosZygoteConnection.processCommand()方法创建进程并启动目标应用程序。我们只需要直到这里是接收AMS创建应用程序的请求，完成目标应用程序创建与启动的就好。详细细节我后面学习到AMS之后，单独写一篇文章来追踪AMS与zygote之间通过socket通信，创建应用程序的过程吧。

3、结语

        总结来说，zygote在开机过程中，其先是启动虚拟机、注册JNI函数、进入java世界，然后fork出system_server进程，之后作为守护进程监听并处理创建普通应用程序的工作。调用流程图原图请见：| ProcessOn