Step 5. ZygoteInit.startSystemServer
       这个函数定义在frameworks/base/core/java/com/android/internal/os/ZygoteInit.java文件中：

1. public class ZygoteInit {
2. ......
3. private static boolean startSystemServer()
4. throws MethodAndArgsCaller, RuntimeException {
5. /* Hardcoded command line to start the system server */
6. String args[] = {
7. "--setuid=1000",
8. "--setgid=1000",
9. "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,3001,3002,3003",
10. "--capabilities=130104352,130104352",
11. "--runtime-init",
12. "--nice-name=system_server",
13. "com.android.server.SystemServer",
14. };
15. ZygoteConnection.Arguments parsedArgs = null;
16. int pid;
17. try {
18. parsedArgs = new ZygoteConnection.Arguments(args);
19. ......
20. /* Request to fork the system server process */
21. pid = Zygote.forkSystemServer(
22. parsedArgs.uid, parsedArgs.gid,
23. parsedArgs.gids, debugFlags, null,
24. parsedArgs.permittedCapabilities,
25. parsedArgs.effectiveCapabilities);
26. } catch (IllegalArgumentException ex) {
27. ......
28. }
29. /* For child process */
30. if (pid == 0) {
31. handleSystemServerProcess(parsedArgs);
32. }
33. return true;
34. }
35. ......
36. }

这里我们可以看到，Zygote进程通过Zygote.forkSystemServer函数来创建一个新的进程来启动SystemServer组件，返回值pid等0的地方就是新的进程要执行的路径，即新创建的进程会执行handleSystemServerProcess函数。

Step 6. ZygoteInit.handleSystemServerProcess
  这个函数定义在frameworks/base/core/java/com/android/internal/os/ZygoteInit.java文件中：

1. 这里我们可以看到，Zygote进程通过Zygote.forkSystemServer函数来创建一个新的进程来启动SystemServer组件，返回值pid等0的地方就是新的进程要执行的路径，即新创建的进程会执行handleSystemServerProcess函数。
2. Step 6. ZygoteInit.handleSystemServerProcess
3. 这个函数定义在frameworks/base/core/java/com/android/internal/os/ZygoteInit.java文件中：

由于由Zygote进程创建的子进程会继承Zygote进程在前面Step 4中创建的Socket文件描述符，而这里的子进程又不会用到它，因此，这里就调用closeServerSocket函数来关闭它。这个函数接着调用RuntimeInit.zygoteInit函数来进一步执行启动SystemServer组件的操作。

Step 7. RuntimeInit.zygoteInit
 这个函数定义在frameworks/base/core/java/com/android/internal/os/RuntimeInit.java文件中：

1. public class RuntimeInit {
2. ......
3. public static final void zygoteInit(String[] argv)
4. throws ZygoteInit.MethodAndArgsCaller {
5. ......
6. zygoteInitNative();
7. ......
8. // Remaining arguments are passed to the start class's static main
9. String startClass = argv[curArg++];
10. String[] startArgs = new String[argv.length - curArg];
11. System.arraycopy(argv, curArg, startArgs, 0, startArgs.length);
12. invokeStaticMain(startClass, startArgs);
13. }
14. ......
15. }

这个函数会执行两个操作，一个是调用zygoteInitNative函数来执行一个Binder进程间通信机制的初始化工作，这个工作完成之后，这个进程中的Binder对象就可以方便地进行进程间通信了，另一个是调用上面Step 5传进来的com.android.server.SystemServer类的main函数。

Step 8. RuntimeInit.zygoteInitNative
这个函数定义在frameworks/base/core/java/com/android/internal/os/RuntimeInit.java文件中：

1. public class RuntimeInit {
2. ......
3. public static final native void zygoteInitNative();
4. ......
5. }

这里可以看出，函数zygoteInitNative是一个Native函数，实现在frameworks/base/core/jni/AndroidRuntime.cpp文件中，这里我们就不再细看了，具体可以参考Android应用程序进程启动过程的源代码分析一文的Step 9，完成这一步后，这个进程的Binder进程间通信机制基础设施就准备好了。

回到Step 7中的RuntimeInit.zygoteInitNative函数，下一步它就要执行com.android.server.SystemServer类的main函数了。

Step 9. SystemServer.main
 这个函数定义在frameworks/base/services/java/com/android/server/SystemServer.java文件中：

1. public class SystemServer
2. {
3. ......
4. native public static void init1(String[] args);
5. ......
6. public static void main(String[] args) {
7. ......
8. init1(args);
9. ......
10. }
11. public static final void init2() {
12. Slog.i(TAG, "Entered the Android system server!");
13. Thread thr = new ServerThread();
14. thr.setName("android.server.ServerThread");
15. thr.start();
16. }
17. ......
18. }

这里的main函数首先会执行JNI方法init1，然后init1会调用这里的init2函数，在init2函数里面，会创建一个ServerThread线程对象来执行一些系统关键服务的启动操作，例如我们在前面两篇文章Android应用程序安装过程源代码分析和Android系统默认Home应用程序（Launcher）的启动过程源代码分析中提到的PackageManagerService和ActivityManagerService。
        这一步的具体执行过程可以参考Android应用程序安装过程源代码分析一文，这里就不再详述了。

这里执行完成后，层层返回，最后回到上面的Step 3中的ZygoteInit.main函数中，接下来它就要调用runSelectLoopMode函数进入一个无限循环在前面Step 4中创建的socket接口上等待ActivityManagerService请求创建新的应用程序进程了。

Step 10. ZygoteInit.runSelectLoopMode
 这个函数定义在frameworks/base/core/java/com/android/internal/os/ZygoteInit.java文件中：

1. public class ZygoteInit {
2. ......
3. private static void runSelectLoopMode() throws MethodAndArgsCaller {
4. ArrayList<FileDescriptor> fds = new ArrayList();
5. ArrayList<ZygoteConnection> peers = new ArrayList();
6. FileDescriptor[] fdArray = new FileDescriptor[4];
7. fds.add(sServerSocket.getFileDescriptor());
8. peers.add(null);
9. int loopCount = GC_LOOP_COUNT;
10. while (true) {
11. int index;
12. ......
13. try {
14. fdArray = fds.toArray(fdArray);
15. index = selectReadable(fdArray);
16. } catch (IOException ex) {
17. throw new RuntimeException("Error in select()", ex);
18. }
19. if (index < 0) {
20. throw new RuntimeException("Error in select()");
21. } else if (index == 0) {
22. ZygoteConnection newPeer = acceptCommandPeer();
23. peers.add(newPeer);
24. fds.add(newPeer.getFileDesciptor());
25. } else {
26. boolean done;
27. done = peers.get(index).runOnce();
28. if (done) {
29. peers.remove(index);
30. fds.remove(index);
31. }
32. }
33. }
34. }
35. ......
36. }

这个函数我们已经在Android应用程序进程启动过程的源代码分析一文的Step 5中分析过了，这就是在等待ActivityManagerService来连接这个Socket，然后调用ZygoteConnection.runOnce函数来创建新的应用程序，有兴趣的读者可以参考Android应用程序进程启动过程的源代码分析这篇文章，这里就不再详述了。

这样，Zygote进程就启动完成了，学习到这里，我们终于都对Android系统中的进程有了一个深刻的认识了，这里总结一下：

1. 系统启动时init进程会创建Zygote进程，Zygote进程负责后续Android应用程序框架层的其它进程的创建和启动工作。

2. Zygote进程会首先创建一个SystemServer进程，SystemServer进程负责启动系统的关键服务，如包管理服务PackageManagerService和应用程序组件管理服务ActivityManagerService。

3. 当我们需要启动一个Android应用程序时，ActivityManagerService会通过Socket进程间通信机制，通知Zygote进程为这个应用程序创建一个新的进程。