Android系统启动_Zygote

在Android中，zygote是整个系统创建新进程的核心进程。zygote进程在内部会先启动Dalvik虚拟机，继而加载一些必要的系统资源和系统类，最后进入一种监听状态。在之后的运作中，当其他系统模块（比如 AMS）希望创建新进程时，只需向zygote进程发出请求，zygote进程监听到该请求后，会相应地fork出新的进程，于是这个新进程在初生之时，就先天具有了自己的Dalvik虚拟机以及系统资源。

关键类	路径
init.rc	system/core/rootdir/init.rc
init.cpp	system/core/init/init.cpp
init.zygote64.rc	system/core/rootdir/init.zygote64.rc
builtins.cpp	system/core/init/builtins.cpp
service.cpp	system/core/init/service.cpp
app_main.cpp	frameworks/base/cmds/app_process/app_main.cpp
AndroidRuntime.cpp	frameworks/base/core/jni/AndroidRuntime.cpp
JniInvocation.cpp	libnativehelper/JniInvocation.cpp
ZygoteInit.java	frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
ZygoteServer.java	frameworks/base/core/java/com/android/internal/os/ZygoteServer.java

在Android系统中，JavaVM(Java虚拟机)、应用程序进程以及运行系统的关键服务的SystemServer进程都是由Zygote进程来创建的，我们也将它称为孵化器。它通过fock(复制进程)的形式来创建应用程序进程和SystemServer进程，由于Zygote进程在启动时会创建JavaVM，因此通过fock而创建的应用程序进程和SystemServer进程可以在内部获取一个JavaVM的实例拷贝。

Zygote触发

在分析init进程时，我们知道init进程启动后，会解析init.rc文件，然后创建和加载service字段指定的进程。zygote进程就是以这种方式，被init进程加载的。

在system/core/rootdir/init.rc的开始部分，可以看到：

import /init.environ.rc
import /init.usb.rc
import /init.${ro.hardware}.rc
import /vendor/etc/init/hw/init.${ro.hardware}.rc
import /init.usb.configfs.rc
import /init.${ro.zygote}.rc           // ${ro.zygote}由厂商定义，与平台相关

on early-init
    # Set init and its forked children's oom_adj.
    write /proc/1/oom_score_adj -1000

init.zygote64_32.rc的代码如下所示：

// 进程名称是zygote,运行的二进制文件在/system/bin/app_process64
// 启动参数是 -Xzygote /system/bin --zygote --start-system-server --socket-name=zygote
service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server --socket-name=zygote
    class main
    priority -20
    user root
    group root readproc
    socket zygote stream 660 root system // 创建一个socket，名字叫zygote，以tcp形式
    // onrestart 指当进程重启时执行后面的命令
    onrestart write /sys/android_power/request_state wake 
    onrestart write /sys/power/state on
    onrestart restart audioserver
    onrestart restart cameraserver
    onrestart restart media
    onrestart restart netd
    onrestart restart wificond
    // 创建子进程时，向 /dev/cpuset/foreground/tasks 写入pid
    writepid /dev/cpuset/foreground/tasks

// 另一个service ,名字 zygote_secondary
service zygote_secondary /system/bin/app_process32 -Xzygote /system/bin --zygote --socket-name=zygote_secondary --enable-lazy-preload
    class main
    priority -20
    user root
    group root readproc
    socket zygote_secondary stream 660 root system
    onrestart restart zygote
    writepid /dev/cpuset/foreground/tasks

start zygote

定义了service，肯定有地方调用 start zygote。在之前init解析的博客中，我们分析过init进程的启动。init进程启动的最后，会产生”late-init”事件。

// Don't mount filesystems or start core system services in charger mode.
std::string bootmode = GetProperty("ro.bootmode", "");
if (bootmode == "charger") {
	am.QueueEventTrigger("charger");
} else {
	am.QueueEventTrigger("late-init");
}

对应于init.rc配置文件中，我们找到如下代码：

# Mount filesystems and start core system services.
on late-init
    trigger early-fs
    ... ...
    # Now we can start zygote for devices with file based encryption
    trigger zygote-start     // 触发了zygote-start事件后，就会启动zygote进程

app_process

​ 从上面我们分析的init.zygote64.rc可以看出，zygote64启动文件的地址为app_process64。app_process64对应的代码定义在frameworks/base/cmds/app_process中

在app_main.cpp的main函数中，主要做的事情就是参数解析. 这个函数有两种启动模式：

• 一种是zygote模式，也就是初始化zygote进程，传递的参数有–start-system-server –socket-name=zygote，前者表示启动SystemServer，后者指定socket的名称（Zygote64_32）。
• 一种是application模式，也就是启动普通应用程序，传递的参数有class名字以及class带的参数。

两者最终都是调用AppRuntime对象的start函数，加载ZygoteInit或RuntimeInit两个Java类，并将之前整理的参数传入进去。

\frameworks\base\cmds\app_process\app_main.cpp

if (zygote) {
	runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
} else if (className) {
	runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
} else {
    fprintf(stderr, "Error: no class name or --zygote supplied.\n");
    app_usage();
    LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
    return 10;
}

AndroidRuntime

由于AppRuntime继承自AndroidRuntime，且没有重写start方法，因此zygote的流程进入到了AndroidRuntime.cpp。

接下来，我们来看看AndroidRuntime的start函数的流程。

创建Java虚拟机

/*
 * Start the Android runtime.  This involves starting the virtual machine
 * and calling the "static void main(String[] args)" method in the class
 * named by "className".
 *
 * Passes the main function two arguments, the class name and the specified
 * options string.
 */
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
    ... ...                                   // 打印一些日志，获取ANDROID_ROOT环境变量

    /* start the virtual machine */
    JniInvocation jni_invocation;
    jni_invocation.Init(NULL);                // 初始化JNI,加载libart.so
    JNIEnv* env;
    // 创建虚拟机，其中大多数参数由系统属性决定
    // 最终，startVm利用JNI_CreateJavaVM创建出虚拟机
    if (startVm(&mJavaVM, &env, zygote) != 0) {
        return;
    }
    // 回调AppRuntime的onVmCreated函数
    // 对于zygote进程的启动流程而言，无实际操作，表示虚拟创建完成，但是里面是空实现
    onVmCreated(env);
    ... ...
}

跟一下jni_invocation.Init() /libnativehelper/JniInvocation.cpp

Init函数主要作用是初始化JNI，具体工作是首先通过dlopen加载libart.so获得其句柄，然后调用dlsym从libart.so中找到JNI_GetDefaultJavaVMInitArgs、JNI_CreateJavaVM、JNI_GetCreatedJavaVMs三个函数地址，赋值给对应成员属性，这三个函数会在后续虚拟机创建中调用。

bool JniInvocation::Init(const char* library) {
#ifdef __ANDROID__
  char buffer[PROP_VALUE_MAX];
#else
  char* buffer = NULL;
#endif
  library = GetLibrary(library, buffer);              // 默认返回 libart.so
  // Load with RTLD_NODELETE in order to ensure that libart.so is not unmapped when it is closed.
  // This is due to the fact that it is possible that some threads might have yet to finish
  // exiting even after JNI_DeleteJavaVM returns, which can lead to segfaults if the library is
  // unloaded.
  const int kDlopenFlags = RTLD_NOW | RTLD_NODELETE;
  
  /*
   * 1.dlopen功能是以指定模式打开指定的动态链接库文件，并返回一个句柄
   * 2.RTLD_NOW表示需要在dlopen返回前，解析出所有未定义符号，如果解析不出来，在dlopen会返回NULL
   * 3.RTLD_NODELETE表示在dlclose()期间不卸载库，并且在以后使用dlopen()重新加载库时不初始化库中的静态变量
   */
  handle_ = dlopen(library, kDlopenFlags);            // 获取libart.so的句柄
  if (handle_ == NULL) {                              // 获取失败打印错误日志并尝试再次打开libart.so
    if (strcmp(library, kLibraryFallback) == 0) {
      // Nothing else to try.
      ALOGE("Failed to dlopen %s: %s", library, dlerror());
      return false;
    }
    // Note that this is enough to get something like the zygote
    // running, we can't property_set here to fix this for the future
    // because we are root and not the system user. See
    // RuntimeInit.commonInit for where we fix up the property to
    // avoid future fallbacks. http://b/11463182
    ALOGW("Falling back from %s to %s after dlopen error: %s",
          library, kLibraryFallback, dlerror());
    library = kLibraryFallback;
    handle_ = dlopen(library, kDlopenFlags);
    if (handle_ == NULL) {
      ALOGE("Failed to dlopen %s: %s", library, dlerror());
      return false;
    }
  }

  /*
   * 1.FindSymbol函数内部实际调用的是dlsym
   * 2.dlsym作用是根据 动态链接库 操作句柄(handle)与符号(symbol)，返回符号对应的地址
   * 3.这里实际就是从libart.so中将JNI_GetDefaultJavaVMInitArgs等对应的地址存入&JNI_GetDefaultJavaVMInitArgs_中
   */
  if (!FindSymbol(reinterpret_cast<void**>(&JNI_GetDefaultJavaVMInitArgs_),
                  "JNI_GetDefaultJavaVMInitArgs")) {
    return false;
  }
  if (!FindSymbol(reinterpret_cast<void**>(&JNI_CreateJavaVM_),
                  "JNI_CreateJavaVM")) {
    return false;
  }
  if (!FindSymbol(reinterpret_cast<void**>(&JNI_GetCreatedJavaVMs_),
                  "JNI_GetCreatedJavaVMs")) {
    return false;
  }
  return true;
}

注册JNI函数

void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
    ... ...

    /* 01. 创建Java虚拟机*/
    
    /*
     * Register android functions.
     */
    if (startReg(env) < 0) {         // 注册JNI函数
        ALOGE("Unable to register all android natives\n");
        return;
    }
    ... ...
}

startReg首先是设置了Android创建线程的处理函数，然后创建了一个200容量的局部引用作用域，用于确保不会出现OutOfMemoryException，最后就是调用register_jni_procs进行JNI注册。

我们跟进startReg()：

/*
 * Register android native functions with the VM.
 */
/*static*/ int AndroidRuntime::startReg(JNIEnv* env)
{
    ATRACE_NAME("RegisterAndroidNatives");
    /*
     * This hook causes all future threads created in this process to be
     * attached to the JavaVM.  (This needs to go away in favor of JNI
     * Attach calls.)
     */
    
 // 定义Android创建线程的func：javaCreateThreadEtc，这个函数内部是通过Linux的clone来创建线程的
    androidSetCreateThreadFunc((android_create_thread_fn) javaCreateThreadEtc);       

    ALOGV("--- registering native functions ---\n");

    /*
     * Every "register" function calls one or more things that return
     * a local reference (e.g. FindClass).  Because we haven't really
     * started the VM yet, they're all getting stored in the base frame
     * and never released.  Use Push/Pop to manage the storage.
     */
    env->PushLocalFrame(200);// 创建一个200容量的局部引用作用域,这个局部引用其实就是局部变量

    if (register_jni_procs(gRegJNI, NELEM(gRegJNI), env) < 0) {       // 注册JNI函数
        env->PopLocalFrame(NULL);
        return -1;
    }

    env->PopLocalFrame(NULL); // 释放局部引用作用域

    //createJavaThread("fubar", quickTest, (void*) "hello");

    return 0;
}

反射启动ZygoteInit

继续分析AndroidRuntime.cpp的start函数：

void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
    ... ...

    /* 01. 创建Java虚拟机*/
    /* 02. 注册JNI函数 */
    
    /*
     * Start VM.  This thread becomes the main thread of the VM, and will
     * not return until the VM exits.
     */

    // 替换string为实际路径
    // 例如：将 "com.android.internal.os.ZygoteInit" 替换为 "com/android/internal/os/ZygoteInit"
    char* slashClassName = toSlashClassName(className != NULL ? className : "");

    jclass startClass = env->FindClass(slashClassName);  // 找到class文件
    if (startClass == NULL) {
        ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
        /* keep going */
    } else {
        jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
            "([Ljava/lang/String;)V");// 通过反射找到ZygoteInit的main函数
        if (startMeth == NULL) {
            ALOGE("JavaVM unable to find main() in '%s'\n", className);
            /* keep going */
        } else {
            // 调用ZygoteInit的main函数
            env->CallStaticVoidMethod(startClass, startMeth, strArray);    
            ... ...
        }
    }
    free(slashClassName);

    ALOGD("Shutting down VM\n");
    if (mJavaVM->DetachCurrentThread() != JNI_OK)  // 退出当前线程
        ALOGW("Warning: unable to detach main thread\n");
    if (mJavaVM->DestroyJavaVM() != 0)  // 创建一个线程，该线程会等待所有子线程结束后关闭虚拟机
        ALOGW("Warning: VM did not shut down cleanly\n");
}

可以看到，在AndroidRuntime的最后，将通过反射调用ZygoteInit的main函数。至此，zygote进程进入了java世界。

• 在Android中，每个进程都运行在对应的虚拟机上，因此zygote首先就负责创建出虚拟机。
• 然后，为了反射调用java代码，必须有对应的JNI函数，于是zygote进行了JNI函数的注册。
• 当一切准备妥当后，zygote进程才进入到了java世界。

ZygoteInit

public static void main(String argv[]) {
    //创建ZygoteServer对象
    ZygoteServer zygoteServer = new ZygoteServer();                             

    // Mark zygote start. This ensures that thread creation will throw
    // an error.
    // 调用native函数，确保当前没有其它线程在运行
    // 主要还是处于安全的考虑
    ZygoteHooks.startZygoteNoThreadCreation();

    // Zygote goes into its own process group.
    try {
    	Os.setpgid(0, 0);
    } catch (ErrnoException ex) {
    	throw new RuntimeException("Failed to setpgid(0,0)", ex);
    }

    final Runnable caller;
    try {
        ... ...
        RuntimeInit.enableDdms();

        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.");
        }

        zygoteServer.registerServerSocket(socketName);        // 注册server socket
        // In some configurations, we avoid preloading resources and classes eagerly.
        // In such cases, we will preload things prior to our first fork.
        if (!enableLazyPreload) {
            ... ...
            preload(bootTimingsTraceLog);   // 默认情况，预加载信息
            ... ...
        } else {
            // 如注释，延迟预加载
            // 变更Zygote进程优先级为NORMAL级别
            // 第一次fork时才会preload
            Zygote.resetNicePriority();
        }

        // Do an initial gc to clean up after startup
        bootTimingsTraceLog.traceBegin("PostZygoteInitGC");
        gcAndFinalize();                                      // 如果预加载了，很有必要GC一波
        bootTimingsTraceLog.traceEnd(); // PostZygoteInitGC

        ... ...

        // Zygote process unmounts root storage spaces.
        Zygote.nativeUnmountStorageOnInit();

        // Set seccomp policy
        // 加载seccomp的过滤规则
        // 所有 Android 软件都使用系统调用（简称为 syscall）与 Linux 内核进行通信
        // 内核提供许多特定于设备和SOC的系统调用，让用户空间进程（包括应用）可以直接与内核进行交互
        // 不过，其中许多系统调用Android未予使用或未予正式支持
        // 通过seccomp，Android可使应用软件无法访问未使用的内核系统调用
        // 由于应用无法访问这些系统调用，因此，它们不会被潜在的有害应用利用
        // 该过滤器安装到zygote进程中，由于所有Android应用均衍生自该进程
        // 因而会影响到所有应用
        Seccomp.setPolicy();

        /// M: Added for BOOTPROF
        addBootEvent("Zygote:Preload End");
        /// @}
        ZygoteHooks.stopZygoteNoThreadCreation();             // 允许有其它线程了

        if (startSystemServer) {
            // fork出system server
            Runnable r = forkSystemServer(abiList, socketName, zygoteServer);    
            if (r != null) {
                r.run();
                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.
        caller = zygoteServer.runSelectLoop(abiList); // zygote进程进入无限循环，处理请求
    } catch (Throwable ex) {
    	... ...
    } finally {
    	zygoteServer.closeServerSocket();
    }

    // We're in the child process and have exited the select loop. Proceed to execute 
    the
    // command.
    if (caller != null) {
    	caller.run();
    }
}

上面是ZygoteInit的main函数的主干部分，除了安全相关的内容外，最主要的工作就是注册server socket、预加载、启动system server及进入无限循环处理请求消息。

创建server socket

/**
* Registers a server socket for zygote command connections
*
* @throws RuntimeException when open fails
*/
private static void registerZygoteSocket(String socketName) {
    if (sServerSocket == null) {
        // ANDROID_SOCKET_PREFIX为"ANDROID_SOCKET_"
        // 此处的socket name，就是zygote
        int fileDesc;
        final String fullSocketName = ANDROID_SOCKET_PREFIX + socketName;
        try {
            // 还记得么？在init.zygote.rc被加载时，指定了名为zygote的socket
            // 在进程被创建时，就会创建对应的文件描述符，并加入到环境变量中
            // 因此，此时可以取出对应的环境变量
            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);// 获取zygote socket的文件描述符
            sServerSocket = new LocalServerSocket(fd);// 将socket包装成一个server socket
        } catch (IOException ex) {
            throw new RuntimeException(
            "Error binding to local socket '" + fileDesc + "'", ex);
        }
    }
}

我们跟踪LocalServerSocket()：

public LocalServerSocket(String name) throws IOException
{
    impl = new LocalSocketImpl();

    impl.create(LocalSocket.SOCKET_STREAM);                 // 创建SOCKET_STREAM类型的AF_UNIX socket

    localAddress = new LocalSocketAddress(name);
    impl.bind(localAddress);                                // 绑定到指定地址

    impl.listen(LISTEN_BACKLOG);                            // 开始监听
}

预加载

static void preload(TimingsTraceLog bootTimingsTraceLog) {
    ... ...
    beginIcuCachePinning(); // Pin ICU Data, 获取字符集转换资源等
    preloadClasses(); // 读取文件system/etc/preloaded-classes，然后通过反射加载对应的类
    // 一般由厂商来定义，有时需要加载数千个类，启动慢的原因之一
    ... ...
    preloadResources(); // 负责加载一些常用的系统资源
    ... ...
    nativePreloadAppProcessHALs();
    ... ...
    preloadOpenGL(); // 图形相关
    ... ...
    preloadSharedLibraries(); // 一些必要库
    preloadTextResources(); // 语言相关的字符信息
    // Ask the WebViewFactory to do any initialization that must run in the zygote process,
    // for memory sharing purposes.
    WebViewFactory.prepareWebViewInZygote();
    endIcuCachePinning();
    warmUpJcaProviders(); // 安全相关的
    Log.d(TAG, "end preload");

    sPreloadComplete = true;
}

为了让系统实际运行时更加流畅，在zygote启动时候，调用preload函数进行了一些预加载操作。Android 通过zygote fork的方式创建子进程。zygote进程预加载这些类和资源，在fork子进程时，仅需要做一个复制即可。
这样可以节约子进程的启动时间。同时，根据fork的copy-on-write机制可知，有些类如果不做改变，甚至都不用复制，子进程可以和父进程共享这部分数据，从而省去不少内存的占用。

启动SystemServer进程

再来看看启动System Server的流程：

/**
* Prepare the arguments and fork for the system server process.
*/
private static boolean startSystemServer(String abiList, String socketName)
throws MethodAndArgsCaller, RuntimeException {
    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_RESOURCE,
        OsConstants.CAP_SYS_TIME,
        OsConstants.CAP_SYS_TTY_CONFIG
    );
    /* Containers run without this capability, so avoid setting it in that case */
    if (!SystemProperties.getBoolean(PROPERTY_RUNNING_IN_CONTAINER, false)) {
    	capabilities |= posixCapabilitiesAsBits(OsConstants.CAP_BLOCK_SUSPEND);
    }
    /* 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,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.applyDebuggerSystemProperty(parsedArgs);
        ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);

        /* Request to fork the system server process */
        pid = Zygote.forkSystemServer(
        parsedArgs.uid, parsedArgs.gid,
        parsedArgs.gids,
        parsedArgs.debugFlags,
        null,
        parsedArgs.permittedCapabilities,
        parsedArgs.effectiveCapabilities);
    } catch (IllegalArgumentException ex) {
    	throw new RuntimeException(ex);
    }

    /* For child process */
    if (pid == 0) {
        if (hasSecondZygote(abiList)) {
        	waitForSecondaryZygote(socketName);
        }
    	handleSystemServerProcess(parsedArgs);
    }
    return true;
}

public static int forkSystemServer(int uid, int gid, int[] gids, int debugFlags,
int[][] rlimits, long permittedCapabilities, long effectiveCapabilities) {
    VM_HOOKS.preFork();
    int pid = nativeForkSystemServer(
    uid, gid, gids, debugFlags, rlimits, permittedCapabilities, effectiveCapabilities);
    // Enable tracing as soon as we enter the system_server.
    if (pid == 0) {
    	Trace.setTracingEnabled(true);
    }
    VM_HOOKS.postForkCommon();
    return pid;
}

创建出SystemServer进程后，zygote进程调用ZygoteServer中的函数runSelectLoop，处理server socket收到的命令。

/**
   * Runs the zygote process's select loop. Accepts new connections as
   * they happen, and reads commands from connections one spawn-request's
   * worth at a time.
   *
   * @throws MethodAndArgsCaller in a child process when a main() should
   * be executed.
   */
  private static void runSelectLoop(String abiList) throws MethodAndArgsCaller {
      ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
      ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
      // 首先将server socket加入到fds
      fds.add(sServerSocket.getFileDescriptor());
      peers.add(null);

      while (true) {
      	// 每次循环，都重新创建需要监听的pollFds
          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;
              }
              // server socket最先加入fds， 因此这里是server socket收到数据
              if (i == 0) {
              	// 收到新的建立通信的请求，建立通信连接
                  ZygoteConnection newPeer = acceptCommandPeer(abiList);
                  // 加入到peers和fds, 即下一次也开始监听
                  peers.add(newPeer);
                  fds.add(newPeer.getFileDesciptor());
              } else {
                  boolean done = peers.get(i).runOnce();
                  if (done) {
                      peers.remove(i);
                      fds.remove(i);
                  }
              }
          }
      }
  }

从上面代码可知，初始时fds中仅有server socket，因此当有数据到来时，将执行i等于0的分支。此时，显然是需要创建新的通信连接，因此acceptCommandPeer将被调用。

我们看看acceptCommandPeer函数：

/**
 * Waits for and accepts a single command connection. Throws
 * RuntimeException on failure.
*/
private static ZygoteConnection acceptCommandPeer(String abiList) {
    try {
        // socket编程中，accept()调用主要用在基于连接的套接字类型，比如SOCK_STREAM和SOCK_SEQPACKET
        // 它提取出所监听套接字的等待连接队列中第一个连接请求，创建一个新的套接字，并返回指向该套接字的文件描述符
        // 新建立的套接字不在监听状态，原来所监听的套接字的状态也不受accept()调用的影响
    	return new ZygoteConnection(sServerSocket.accept(), abiList);
    } catch (IOException ex) {
        throw new RuntimeException(
        "IOException during accept()", ex);
    }
}

从上面的代码，可以看出acceptCommandPeer调用了server socket的accpet函数。于是当新的连接建立时，zygote将会创建出一个新的socket与其通信，并将该socket加入到fds中。因此，一旦通信连接建立后，fds中将会包含有多个socket。

当poll监听到这一组sockets上有数据到来时，就会从阻塞中恢复。于是，我们需要判断到底是哪个socket收到了数据。

在runSelectLoop中采用倒序的方式轮询。由于server socket第一个被加入到fds，因此最后轮询到的socket才需要处理新建连接的操作；其它socket收到数据时，仅需要调用zygoteConnection的runonce函数执行数据对应的操作。若一个连接处理完所有对应消息后，该连接对应的socket和连接等将被移除。

总结

Zygote启动流程到此结束，Zygote进程共做了如下几件事：

1. 创建AppRuntime并调用其start方法，启动Zygote进程。
2. 创建JavaVM并为JavaVM注册JNI。
3. 通过JNI调用ZygoteInit的main函数进入Zygote的Java框架层。
4. 通过registerZygoteSocket函数创建服务端Socket，预加载类和资源，并通过runSelectLoop函数等待如ActivityManagerService等的请求。
5. 启动SystemServer进程。

原文：https://www.cnblogs.com/pepsimaxin/p/9448874.html