Step 2. AndroidRuntime.start

        这个函数定义在frameworks/base/core/jni/AndroidRuntime.cpp文件中：

1. /*  
2. * Start the Android runtime.  This involves starting the virtual machine  
3. * and calling the "static void main(String[] args)" method in the class  
4. * named by "className".  
5. */   
6. void AndroidRuntime::start(const char* className, const bool startSystemServer)   
7. {   
8.     ......   
9.    
10.     char* slashClassName = NULL;   
11.     char* cp;   
12.     JNIEnv* env;   
13.    
14.     ......   
15.    
16.     /* start the virtual machine */   
17.     if (startVm(&mJavaVM, &env) != 0)   
18.         goto bail;   
19.    
20.     /*  
21.     * Register android functions.  
22.     */   
23.     if (startReg(env) < 0) {   
24.         LOGE("Unable to register all android natives\n");   
25.         goto bail;   
26.     }   
27.    
28.     /*  
29.     * We want to call main() with a String array with arguments in it.  
30.     * At present we only have one argument, the class name.  Create an  
31.     * array to hold it.  
32.     */   
33.     jclass stringClass;   
34.     jobjectArray strArray;   
35.     jstring classNameStr;   
36.     jstring startSystemServerStr;   
37.     stringClass = env->FindClass("java/lang/String");   
38.     assert(stringClass != NULL);   
39.     strArray = env->NewObjectArray(2, stringClass, NULL);   
40.     assert(strArray != NULL);   
41.     classNameStr = env->NewStringUTF(className);   
42.     assert(classNameStr != NULL);   
43.     env->SetObjectArrayElement(strArray, 0, classNameStr);   
44.     startSystemServerStr = env->NewStringUTF(startSystemServer ?   
45.         "true" : "false");   
46.     env->SetObjectArrayElement(strArray, 1, startSystemServerStr);   
47.    
48.     /*  
49.     * Start VM.  This thread becomes the main thread of the VM, and will  
50.     * not return until the VM exits.  
51.     */   
52.     jclass startClass;   
53.     jmethodID startMeth;   
54.    
55.     slashClassName = strdup(className);   
56.     for (cp = slashClassName; *cp != '\0'; cp++)   
57.         if (*cp == '.')   
58.             *cp = '/';   
59.    
60.     startClass = env->FindClass(slashClassName);   
61.     if (startClass == NULL) {   
62.         ......   
63.     } else {   
64.         startMeth = env->GetStaticMethodID(startClass, "main",   
65.             "([Ljava/lang/String;)V");   
66.         if (startMeth == NULL) {   
67.             ......   
68.         } else {   
69.             env->CallStaticVoidMethod(startClass, startMeth, strArray);   
70.             ......   
71.         }   
72.     }   
73.    
74.     ......   
75. }   

     这个函数的作用是启动Android系统运行时库，它主要做了三件事情，一是调用函数startVM启动虚拟机，二是调用函数startReg注册JNI方法，三是调用了com.android.internal.os.ZygoteInit类的main函数。

        Step 3. ZygoteInit.main

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

1. public class ZygoteInit {   
2.     ......   
3.    
4.     public static void main(String argv[]) {   
5.         try {   
6.             ......   
7.    
8.             registerZygoteSocket();   
9.                
10.             ......   
11.    
12.             ......   
13.    
14.             if (argv[1].equals("true")) {   
15.                 startSystemServer();   
16.             } else if (!argv[1].equals("false")) {   
17.                 ......   
18.             }   
19.    
20.             ......   
21.    
22.             if (ZYGOTE_FORK_MODE) {   
23.                 ......   
24.             } else {   
25.                 runSelectLoopMode();   
26.             }   
27.    
28.             ......   
29.         } catch (MethodAndArgsCaller caller) {   
30.             ......   
31.         } catch (RuntimeException ex) {   
32.             ......   
33.         }   
34.     }   
35.    
36.     ......   
37. }   

  它主要作了三件事情，一个调用registerZygoteSocket函数创建了一个socket接口，用来和ActivityManagerService通讯，二是调用startSystemServer函数来启动SystemServer组件，三是调用runSelectLoopMode函数进入一个无限循环在前面创建的socket接口上等待ActivityManagerService请求创建新的应用程序进程。

         Step 4. ZygoteInit.registerZygoteSocket

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

1. public class ZygoteInit {   
2.     ......   
3.    
4.     /**  
5.     * Registers a server socket for zygote command connections  
6.     *  
7.     * @throws RuntimeException when open fails  
8.     */   
9.     private static void registerZygoteSocket() {   
10.         if (sServerSocket == null) {   
11.             int fileDesc;   
12.             try {   
13.                 String env = System.getenv(ANDROID_SOCKET_ENV);   
14.                 fileDesc = Integer.parseInt(env);   
15.             } catch (RuntimeException ex) {   
16.                 ......   
17.             }   
18.    
19.             try {   
20.                 sServerSocket = new LocalServerSocket(   
21.                     createFileDescriptor(fileDesc));   
22.             } catch (IOException ex) {   
23.                 .......   
24.             }   
25.         }   
26.     }   
27.            
28.     ......   
29. }   

这个socket接口是通过文件描述符来创建的，这个文件描符代表的就是我们前面说的/dev/socket/zygote文件了。这个文件描述符是通过环境变量ANDROID_SOCKET_ENV得到的，它定义为：

1. public class ZygoteInit {  
2.     ......  
3.   
4.     private static final String ANDROID_SOCKET_ENV = "ANDROID_SOCKET_zygote";  
5.           
6.     ......  
7. }  

    那么，这个环境变量的值又是由谁来设置的呢？我们知道，系统启动脚本文件system/core/rootdir/init.rc是由init进程来解释执行的，而init进程的源代码位于system/core/init目录中，在init.c文件中，是由service_start函数来解释init.rc文件中的service命令的：

1. void service_start(struct service *svc, const char *dynamic_args)  
2. {  
3.     ......  
4.   
5.     pid_t pid;  
6.   
7.     ......  
8.   
9.     pid = fork();  
10.   
11.     if (pid == 0) {  
12.         struct socketinfo *si;  
13.   
14.         ......  
15.   
16.         for (si = svc->sockets; si; si = si->next) {  
17.             int socket_type = (  
18.                 !strcmp(si->type, "stream") ? SOCK_STREAM :  
19.                 (!strcmp(si->type, "dgram") ? SOCK_DGRAM : SOCK_SEQPACKET));  
20.             int s = create_socket(si->name, socket_type,  
21.                 si->perm, si->uid, si->gid);  
22.             if (s >= 0) {  
23.                 publish_socket(si->name, s);  
24.             }  
25.         }  
26.   
27.         ......  
28.     }  
29.   
30.     ......  
31. }  

 每一个service命令都会促使init进程调用fork函数来创建一个新的进程，在新的进程里面，会分析里面的socket选项，对于每一个socket选项，都会通过create_socket函数来在/dev/socket目录下创建一个文件，在这个场景中，这个文件便是zygote了，然后得到的文件描述符通过publish_socket函数写入到环境变量中去：

1. static void publish_socket(const char *name, int fd)  
2. {  
3.     char key[64] = ANDROID_SOCKET_ENV_PREFIX;  
4.     char val[64];  
5.   
6.     strlcpy(key + sizeof(ANDROID_SOCKET_ENV_PREFIX) - 1,  
7.             name,  
8.             sizeof(key) - sizeof(ANDROID_SOCKET_ENV_PREFIX));  
9.     snprintf(val, sizeof(val), "%d", fd);  
10.     add_environment(key, val);  
11.   
12.     /* make sure we don't close-on-exec */  
13.     fcntl(fd, F_SETFD, 0);  
14. }  

这里传进来的参数name值为"zygote"，而ANDROID_SOCKET_ENV_PREFIX在system/core/include/cutils/sockets.h定义为：#define ANDROID_SOCKET_ENV_PREFIX   "ANDROID_SOCKET_"     因此，这里就把上面得到的文件描述符写入到以"ANDROID_SOCKET_zygote"为key值的环境变量中。又因为上面的ZygoteInit.registerZygoteSocket函数与这里创建socket文件的create_socket函数是运行在同一个进程中，因此，上面的ZygoteInit.registerZygoteSocket函数可以直接使用这个文件描述符来创建一个Java层的LocalServerSocket对象。如果其它进程也需要打开这个/dev/socket/zygote文件来和Zygote进程进行通信，那就必须要通过文件名来连接这个LocalServerSocket了，参考Android应用程序进程启动过程的源代码分析一文中的Step 4，ActivityManagerService是通过Process.start函数来创建一个新的进程的，而Process.start函数会首先通过Socket连接到Zygote进程中，最终由Zygote进程来完成创建新的应用程序进程，而Process类是通过openZygoteSocketIfNeeded函数来连接到Zygote进程中的Socket的：

1. public class Process {     
2.     ......     
3.     
4.     private static void openZygoteSocketIfNeeded()     
5.             throws ZygoteStartFailedEx {     
6.    
7.         ......   
8.    
9.         for (int retry = 0     
10.             ; (sZygoteSocket == null) && (retry < (retryCount + 1))     
11.             ; retry++ ) {     
12.    
13.                 ......   
14.    
15.                 try {     
16.                     sZygoteSocket = new LocalSocket();     
17.                     sZygoteSocket.connect(new LocalSocketAddress(ZYGOTE_SOCKET,     
18.                         LocalSocketAddress.Namespace.RESERVED));     
19.    
20.                     sZygoteInputStream     
21.                         = new DataInputStream(sZygoteSocket.getInputStream());     
22.    
23.                     sZygoteWriter =     
24.                         new BufferedWriter(     
25.                         new OutputStreamWriter(     
26.                         sZygoteSocket.getOutputStream()),     
27.                         256);     
28.    
29.                     ......     
30.                 } catch (IOException ex) {     
31.                     ......     
32.                 }     
33.         }     
34.    
35.         ......     
36.     }     
37.    
38.     ......     
39. }   

 这里的ZYGOTE_SOCKET定义为：

1. public class Process {    
2.     ......    
3.    
4.     private static final String ZYGOTE_SOCKET = "zygote";    
5.   
6.     ......    
7. }   

   它刚好就是对应/dev/socket目录下的zygote文件了。

        Android系统中的socket机制和binder机制一样，都是可以用来进行进程间通信，读者可以自己对比一下这两者的不同之处，Binder进程间通信机制可以参考Android进程间通信（IPC）机制Binder简要介绍和学习计划一文。

       Socket对象创建完成之后，回到Step 3中的ZygoteInit.main函数中，startSystemServer函数来启动SystemServer组件。