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

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

   这里我们可以看到，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.    
4.     public static final void zygoteInit(String[] argv)     
5.             throws ZygoteInit.MethodAndArgsCaller {     
6.         ......     
7.      
8.         zygoteInitNative();     
9.    
10.         ......     
11.    
12.    
13.         // Remaining arguments are passed to the start class's static main     
14.    
15.         String startClass = argv[curArg++];     
16.         String[] startArgs = new String[argv.length - curArg];     
17.    
18.         System.arraycopy(argv, curArg, startArgs, 0, startArgs.length);     
19.         invokeStaticMain(startClass, startArgs);     
20.     }     
21.    
22.     ......     
23. }   

 这个函数会执行两个操作，一个是调用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.   
4.     public static final native void zygoteInitNative();    
5.   
6.     ......    
7. }  

这里可以看出，函数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.    
5.     native public static void init1(String[] args);     
6.    
7.     ......     
8.    
9.     public static void main(String[] args) {     
10.         ......     
11.    
12.         init1(args);     
13.    
14.         ......     
15.     }    
16.    
17.     public static final void init2() {     
18.         Slog.i(TAG, "Entered the Android system server!");     
19.         Thread thr = new ServerThread();     
20.         thr.setName("android.server.ServerThread");     
21.         thr.start();     
22.     }     
23.    
24.     ......     
25. }   

 这里的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.    
4.     private static void runSelectLoopMode() throws MethodAndArgsCaller {   
5.         ArrayList<FileDescriptor> fds = new ArrayList();   
6.         ArrayList<ZygoteConnection> peers = new ArrayList();   
7.         FileDescriptor[] fdArray = new FileDescriptor[4];   
8.    
9.         fds.add(sServerSocket.getFileDescriptor());   
10.         peers.add(null);   
11.    
12.         int loopCount = GC_LOOP_COUNT;   
13.         while (true) {   
14.             int index;   
15.    
16.             ......   
17.    
18.    
19.             try {   
20.                 fdArray = fds.toArray(fdArray);   
21.                 index = selectReadable(fdArray);   
22.             } catch (IOException ex) {   
23.                 throw new RuntimeException("Error in select()", ex);   
24.             }   
25.    
26.             if (index < 0) {   
27.                 throw new RuntimeException("Error in select()");   
28.             } else if (index == 0) {   
29.                 ZygoteConnection newPeer = acceptCommandPeer();   
30.                 peers.add(newPeer);   
31.                 fds.add(newPeer.getFileDesciptor());   
32.             } else {   
33.                 boolean done;   
34.                 done = peers.get(index).runOnce();   
35.    
36.                 if (done) {   
37.                     peers.remove(index);   
38.                     fds.remove(index);   
39.                 }   
40.             }   
41.         }   
42.     }   
43.    
44.     ......   
45. }         

这个函数我们已经在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进程为这个应用程序创建一个新的进程。