這篇文章主要介紹了詳細分析Android中實現Zygote的源碼,包括底層的C/C++代碼以及Java代碼部分入口,需要的朋友可以參考下

概述

在Android系統中，所有的應用程序進程，以及用來運行系統關鍵服務的System進程都是由zygote進程負責創建的。因此，我們將它稱為進程孵化器。zygote進程是通過復制自身的方式來創建System進程和應用程序進程的。由于zygote進程在啟動時會在內部創建一個虛擬機實例，因此，通過復制zygote進程而得到的System進程和應用程序進程可以快速地在內部獲得一個虛擬機實例拷貝。

zygote進程在啟動完成之后，會馬上將System進程啟動起來，以便它可以將系統的關鍵服務啟動起來。下面我們將介紹zygote進程的啟動腳本，然后分析它和System進程的啟動過程。

zygote分析

zygote進程的啟動腳本如下：

1. service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server 
2. class main 
3. socket zygote stream 660 root system 
4. onrestart write /sys/android_power/request_state wake 
5. onrestart write /sys/power/state on 
6. onrestart restart media 
7. onrestart restart netd 

解析配置文件

在我之前的一篇博客中已經分析了init進程是如何啟動service服務了，需要了解的同學可以參考這篇文章：Android init進程——

通過zygote服務的啟動腳本，我們可以知道，zygote進程的實際是二進制文件app_process的調用，我們就從這個應用程序的main函數入手去分析一下zygote進程的啟動過程，源碼如下(/frameworks/base/cmds/app_process/app_main.cpp)：

1. /** 
2. * 將-Xzygote加入到JavaVMOption中，返回/system/bin參數指向的下標 
3. */ 
4. int AndroidRuntime::addVmArguments(int argc, const char* const argv[]) 
5. { 
6. int i; 
7.  
8. for (i = 0; i < argc; i ++) { 
9. if (argv[i][0] != '-') { 
10. return i; 
11. } 
12. if (argv[i][1] == '-' && argv[i][2] == 0) { 
13. return i + 1; 
14. } 
15.  
16. JavaVMOption opt; 
17. memset(&opt, 0, sizeof(opt)); 
18. opt.optionString = (char*)argv[i]; 
19. mOptions.add(opt); 
20. } 
21. return i; 
22. } 
23.  
24. int main(int argc, char* const argv[]) 
25. { 
26. // zygote call parameters 
27. // /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server 
28.  
29. // These are global variables in ProcessState.cpp 
30. mArgC = argc; 
31. mArgV = argv; 
32.  
33. mArgLen = 0; 
34. for (int i = 0; i < argc; i ++) { 
35. mArgLen += strlen(argv[i]) + 1; 
36. } 
37. // 去除末尾的空格 
38. mArgLen--; 
39.  
40. AppRuntime runtime; 
41. const char* argv0 = argv[0]; 
42.  
43. // Process command line arguments 
44. // ignore argv[0] 
45. argc --; 
46. argv ++; 
47.  
48. // Everything up tp '--' or first non '-' arg goes to the vm 
49. int i = runtime.addVmArguments(argc, argv); 
50.  
51. // Parse runtime arguments. Stop at first unrecognized option. 
52. bool zygote = false; 
53. bool startSystemServer = false; 
54. bool application = false; 
55. const char* parentDir = NULL; 
56. const char* niceName = NULL; 
57. const char* className = NULL; 
58. while (i < argc) { 
59. const char* arg = argv[i ++]; 
60. if (!parentDir) { 
61. parentDir = arg; 
62. } else if (strcmp(arg, "--zygote") == 0) { 
63. zygote = true; 
64. niceName = "zygote"; 
65. } else if (strcmp(arg, "--start-system-server") == 0) { 
66. startSystemServer = true; 
67. } else if (strcmp(arg, "--application") == 0) { 
68. application = true; 
69. } else if (strncmp(arg, "--nice-name=", 12)) { 
70. niceName = arg + 12; 
71. } else { 
72. className = arg; 
73. break; 
74. } 
75. } 
76.  
77. if (niceName && *niceName) { 
78. setArgv0(argv0, niceName); 
79. set_process_name(niceName); 
80. } 
81.  
82. runtime.mParentDir = parentDir; 
83.  
84. if (zygote) { 
85. // 進入到AppRuntime的start函數 
86. runtime.start("com.android.internal.os.ZygoteInit", 
87. startSystemServer? "start-system-server" : ""); 
88. } else if (className) { 
89. runtime.mClassName = className; 
90. runtime.mArgc = argc - i; 
91. runtime.mArgv = argv + i; 
92. runtime.start("com.android.internal.os.RuntimeInit", application ? "application" : "tool"); 
93. } else { 
94. fprintf("stderr", "Error: no class name or --zygote supplied./n"); 
95. app_usage(); 
96. LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied"); 
97. return 10; 
98. } 
99. } 

在zygote的main函數中，通過AppRuntime runtime代碼創建了一個AppRuntime對象runtime，接下來Zygote進程就是通過它來進一步啟動的。

init.rc中關于啟動zygote命令中包含了–zygote參數，所以在if(strcmp(arg, “–zygote”) == 0)判斷的時候，會將niceName賦值為”zygote”,然后通過set_process_name(niceName)函數將當前進程的名稱設置為zygote。這也是為什么調用的腳本為/system/bin/app_process，而進程名為zygote的原因。set_process_name函數的源碼如下(/system/core/libcutils/process_name.c)：

1. static const char* process_name = "unknown"; 
2. void set_process_name(const char* new_name) 
3. { 
4. if (new_name == NULL) { 
5. return; 
6. } 
7.  
8. int len = strlen(new_name); 
9. char* copy = (char*)malloc(len + 1); 
10. strcpy(copy, new_name); 
11. process_name = (const char*) copy; 
12. } 

從init.rc文件中關于zygote進程的配置參數可知，Zygote進程傳遞給應用程序app_process的啟動參數arg還包含一個”–start-system-server”選項。因此，在調用AppRuntime對象runtime的成員函數start時，第二個參數為”start-system-server”，表示zygote進程啟動完成之后，需要將system進程啟動起來。

AppRuntime分析

AppRuntime類的成員函數start是從父類AndroidRuntime繼承下來的，因此，接下來我們就繼續分析AndroidRuntime類的成員函數start的實現，函數源碼位置：/frameworks/base/core/jni/AndroidRuntime.cpp：

1. char* AndroidRuntime::toSlashClassName(const char* className) 
2. { 
3. char* result = strdup(className); 
4. for (char* cp = result; *cp != '/0'; cp ++) { 
5. if (*cp == '.') { 
6. *cp = '/'; 
7. } 
8. } 
9.  
10. return result; 
11. } 
12.  
13. /** 
14. * Start the Android runtime. This involves starting the virtual machine 
15. * and calling the "static void main(String[] args)" method int the class 
16. * named by "className". 
17. * 
18. * 這兩個參數的值分別為: 
19. * const char* className = "com.android.internal.os.ZygoteInit"; 
20. * const char* options = "start-system-server"; 
21. */ 
22. void AndroidRuntime::start(const char* className, const char* options) 
23. { 
24. ALOGD("/n>>>>> AndroidRuntime START %s <<<<<</n", 
25. className != NULL ? className : "(unknown)"); 
26.  
27. /** 
28. * 'startSystemServer == true' means runtime is obsolete and not run from 
29. * init.rc anymore, so we print out the boot start event here. 
30. */ 
31. if (strcmp(options, "start-system-server") == 0) { 
32. const int LOG_BOOT_PROGRESS_START = 3000; 
33. LOG_EVENT_LONG(LOG_BOOT_PROGRESS_START, ns2ms(systemTime(SYSTEM_TIME_MONOTONIC))); 
34. } 
35.  
36. // 設置ANDROID_ROOT環境變量 
37. const char* rootDir = getenv("ANDROID_ROOT"); 
38. if (rootDir == NULL) { 
39. rootDir = "/system"; 
40. if (!hasDir("/system")) { 
41. LOG_FATAL("No root directory specified, and /android dose not exist."); 
42. return; 
43. } 
44. setenv("ANDROID_ROOT", rootDir, 1); 
45. } 
46.  
47.  
48. JniInvocation jni_invocation; 
49. jni_invocation.Init(NULL); 
50. JNIEnv* env; 
51. // 1. 創建虛擬機 
52. if (startVm(&mJavaVM, &env) != 0) { 
53. return; 
54. } 
55. onVmCreated(env); 
56.  
57. // 2. 注冊JNI函數 
58. if (startReg(env) < 0) { 
59. ALOGE("Unable to register all android natives/n"); 
60. return; 
61. } 
62.  
63. jclass stringClass; 
64. jobjectArray strArray; 
65. jstring classNameStr; 
66. jstring optionsStr; 
67.  
68. stringClass = env->FindClass("java/lang/String"); 
69. assert(stringClass != NULL); 
70. // 創建一個有兩個元素的String數組，用Java代碼表示為:String[] strArray = new String[2]; 
71. strArray = env->NewObjectArray(2, stringClass, NULL); 
72. assert(strArray != NULL); 
73. classNameStr = env->NewStringUTF(className); 
74. assert(classNameStr != NULL); 
75. // 設置第一個元素為"com.android.internal.os.ZygoteInit" 
76. env->SetObjectArrayElement(strArray, 0, classNameStr); 
77. optionsStr = env->NewStringUTF(options); 
78. // 設置第二個元素為"start-system-server" 
79. env->SetObjectArrayElement(strArray, 1, optionsStr); 
80.  
81. // 將字符串"com.android.internal.os.ZygoteInit"轉換為"com/android/internal/os/ZygoteInit" 
82. char* slashClassName = toSlashClassName(className); 
83. jclass startClass = env->FindClass(slashClassName); 
84. if (startClass == NULL) { 
85. ALOGE("JavaVM unable to locate class '%s'/n", slashClassName); 
86. } else { 
87. jmethodID startMeth = env->GetStaticMethodID(startClass, "main", "([Ljava/lang/String;)V"); 
88. if (startMeth == NULL) { 
89. ALOGE("JavaVM unable to find main() in '%s/n'", className); 
90. } else { 
91. // 3. 
92. // 通過JNI調用java函數，注意調用的是main函數，所屬的類是"com.android.internal.os.ZygoteInit". 
93. // 傳遞的參數是"com.android.internal.os.ZygoteInit true" 
94. env->CallStaticVoidMethod(startClass, startMeth, strArray); 
95. } 
96. } 
97. free(slashClassName); 
98.  
99. ALOGD("Shutting down VM/n"); 
100. if (mJavaVM->DetachCurrentThread() != JNI_OK) { 
101. ALOGW("Warning: unable to detach main thread/n"); 
102. } 
103. if (mJavaVM->DestoryJavaVM() != 0) { 
104. ALOGW("Warning: VM did not shut down cleanly/n"); 
105. } 
106. } 

上述代碼有幾處關鍵點，分別是：

創建虛擬機。

注冊JNI函數。

進入Java世界。

接下來，我們分別分析這三個關鍵點。

創建虛擬機——startVm

startVm并沒有特別之處，就是調用JNI的虛擬機創建函數，但是創建虛擬機時的一些參數卻是在startVm中確定的，其源碼如下：

1. #define PROPERTY_VALUE_MAX 92 
2. /** 
3. * Start the Dalvik Virtual Machine. 
4. * 
5. * Various arguments, most determined by system properties, are passed in. 
6. * The "mOptions" vector is updated. 
7. * 
8. * Returns 0 on success. 
9. */ 
10. int AndroidRuntime::startVm(JavaVM** pJavaVM, JNIENV** pEnv) 
11. { 
12. int result = -1; 
13. JavaVMInitArgs initArgs; 
14. JavaVMOption opt; 
15. char propBuf[PROPERTY_VALUE_MAX]; 
16. char stackTraceFileBuf[PROPERTY_VALUE_MAX]; 
17. char dexoptFlagsBuf[PROPERTY_VALUE_MAX]; 
18. char enableAssertBuf[sizeof("-ea:")-1 + PROPERTY_VALUE_MAX]; 
19. char jniOptsBuf[sizeof("-Xjniopts:")-1 + PROPERTY_VALUE_MAX]; 
20. char heapstartsizeOptsBuf[sizeof("-Xms")-1 + PROPERTY_VALUE_MAX]; 
21. char heapsizeOptsBuf[sizeof("-Xms")-1 + PROPERTY_VALUE_MAX]; 
22. char heapgrowthlimitOptsBuf[sizeof("-XX:HeapGrowthLimit=")-1 + PROPERTY_VALUE_MAX]; 
23. char heapminfreeOptsBuf[sizeof("-XX:HeapMinFree=")-1 + PROPERTY_VALUE_MAX]; 
24. char heapmaxfreeOptsBuf[sizeof("-XX:HeapMaxFree=")-1 + PROPERTY_VALUE_MAX]; 
25. char heaptargetutilizationOptsBuf[sizeof("-XX:HeapTargetUtilization=")-1 + PROPERTY_VALUE_MAX]; 
26. char jitcodecachesizeOptsBuf[sizeof("-Xjitcodecachesize:")-1 + PROPERTY_VALUE_MAX]; 
27. char extraOptsBuf[PROPERTY_VALUE_MAX]; 
28. char* stackTraceFile = NULL; 
29. bool checkJni = false; 
30. bool checkDexSum = false; 
31. bool logStdio = false; 
32. enum { 
33. KEMDefault, 
34. KEMIntPortable, 
35. KEMIntFast, 
36. KEMJitCompiler, 
37. } executionMode = KEMDefault; 
38.  
39. /** 
40. * 這段代碼是用了設置JNI_check選項的。JNI_check指的是Native層調用JNI函數時，系統所做的一些檢查動作。 
41. * 這個選項雖然能增加可靠性，但是還有一些副作用： 
42. * 1. 因為檢查工作比較耗時，所以會影響系統運行速度。 
43. * 2. 有些檢查工作比較耗時，一旦出錯，整個進程會abort。 
44. * 所以，JNI_check選項一般只在eng版本設置。 
45. */ 
46. property_get("dalvik.vm.checkjni", propBuf, ""); 
47. if (strcmp(propBuf, "true") == 0) { 
48. checkJni = true; 
49. } else if (strcmp(propBuf, "false") != 0) { 
50. property_get("ro.kernel.android.checkjni", propBuf, ""); 
51. if (propBuf[0] == '1') { 
52. checkJni = true; 
53. } 
54. } 
55.  
56. property_get("dalvik.vm.execution-mode", propBuf, ""); 
57. if (strcmp(propBuf, "int:portable") == 0) { 
58. executionMode = KEMIntPortable; 
59. } else if (strcmp(propBuf, "int:fast") == 0) { 
60. executionMode = KEMIntFast;  
61. } else if (strcmp(propBuf, "int:jit") == 0) { 
62. executionMode = KEMJitCompiler; 
63. } 
64.  
65. // ... 省略大部分參數設置 
66.  
67. /** 
68. * 設置虛擬機的heapsize，默認為16m。絕大多數廠商都會在build.prop文件里修改這個屬性，一般是256m。 
69. * heapsize不能設置得過小，否則在操作大尺寸的圖片時無法分配所需的內存。 
70. */ 
71. strcpy(heapsizeOptsBuf, "-Xmx"); 
72. property_get("dalvik.vm.heapsize", heapsizeOptsBuf+4, "16m"); 
73. opt.optionString = heapsizeOptsBuf; 
74. mOptions.add(opt); 
75.  
76. // ...... 
77.  
78. if (JNI_CreateJavaVM(pJavaVM, pEnv, &initArgs) < 0) { 
79. ALOGE("JNI_CreateJavaVM failed/n"); 
80. goto bail; 
81. } 
82.  
83. result = 0; 
84.  
85. bail: 
86. free(stackTraceFile); 
87. return result; 
88. } 

更多虛擬機參數的設置，我這里就不做特殊說明了，大家感興趣可以自行google。(ps:因為我不太懂虛擬機這一塊…)

注冊JNI函數——startReg

上面講了如何創建虛擬機，接下來需要給這個虛擬機注冊一些JNI函數。正是因為后續的Java世界用到的一些函數是采用native方式實現的，所以才必須提前注冊這些函數。

接下來，我們來看一下startReg函數的源碼實現：

1. int AndroidRuntime::startReg(JNIEnv* env) 
2. { 
3. // 設置Thread類的線程創建函數為javaCreateThreadEtc 
4. androidSetCreateThreadFunc((android_create_thread_fn) javaCreateThreadEtc); 
5.  
6. ALOGV("--- registering native functions ---/n"); 
7.  
8. env->PushLocalFrame(200); 
9.  
10. if (register_jni_procs(gRegJNI, NELEM(gRegJNI), env) < 0) { 
11. env->PopLocalFrame(NULL); 
12. return -1; 
13. } 
14. env->PopLocalFrame(NULL); 
15.  
16. return 0; 
17. } 

關鍵是需要注冊JNI函數，具體實現是由register_jni_procs函數實現的，我們來看一下這個函數的具體實現(/frameworks/base/core/jni/AndroidRuntime.cpp)：

1. static int register_jni_procs(const RegJNIRec array[], size_T count, JNIEnv* env) 
2. { 
3. for (size_t i = 0; i < count; i ++) { 
4. if (array[i].mProc(env) < 0) { 
5. #ifndef NDEBUG 
6. ALOGD("------!!! %s failed to load/n", array[i].mName); 
7. #endif 
8. return -1; 
9. } 
10. } 
11.  
12. return 0; 
13. } 

通過源碼，我們可以看到，register_jni_procs只是對array數組的mProc函數的封裝，而array數組指向的是gRegJNI數組，我們來看一下這個數組的實現：

1. static const RegJNIRec gRegJNI[] = { 
2. REG_JNI(register_android_debug_JNITest), 
3. REG_JNI(register_com_android_internal_os_RuntimeInit), 
4. REG_JNI(register_android_os_SystemClock), 
5. REG_JNI(register_android_util_EventLog), 
6. REG_JNI(register_android_util_Log), 
7. REG_JNI(register_android_util_FloatMath), 
8. REG_JNI(register_android_text_format_Time), 
9. REG_JNI(register_android_content_AssetManager), 
10. REG_JNI(register_android_content_StringBlock), 
11. REG_JNI(register_android_content_XmlBlock), 
12. REG_JNI(register_android_emoji_EmojiFactory), 
13. REG_JNI(register_android_text_AndroidCharacter), 
14. REG_JNI(register_android_text_AndroidBidi), 
15. REG_JNI(register_android_view_InputDevice), 
16. REG_JNI(register_android_view_KeyCharacterMap), 
17. REG_JNI(register_android_os_Process), 
18. REG_JNI(register_android_os_SystemProperties), 
19. REG_JNI(register_android_os_Binder), 
20. REG_JNI(register_android_os_Parcel), 
21. REG_JNI(register_android_view_DisplayEventReceiver), 
22. REG_JNI(register_android_nio_utils), 
23. REG_JNI(register_android_graphics_Graphics), 
24. REG_JNI(register_android_view_GraphicBuffer), 
25. REG_JNI(register_android_view_GLES20DisplayList), 
26. REG_JNI(register_android_view_GLES20Canvas), 
27. REG_JNI(register_android_view_HardwareRenderer), 
28. REG_JNI(register_android_view_Surface), 
29. REG_JNI(register_android_view_SurfaceControl), 
30. REG_JNI(register_android_view_SurfaceSession), 
31. REG_JNI(register_android_view_TextureView), 
32. REG_JNI(register_com_google_android_gles_jni_EGLImpl), 
33. REG_JNI(register_com_google_android_gles_jni_GLImpl), 
34. REG_JNI(register_android_opengl_jni_EGL14), 
35. REG_JNI(register_android_opengl_jni_EGLExt), 
36. REG_JNI(register_android_opengl_jni_GLES10), 
37. REG_JNI(register_android_opengl_jni_GLES10Ext), 
38. REG_JNI(register_android_opengl_jni_GLES11), 
39. REG_JNI(register_android_opengl_jni_GLES11Ext), 
40. REG_JNI(register_android_opengl_jni_GLES20), 
41. REG_JNI(register_android_opengl_jni_GLES30), 
42.  
43. REG_JNI(register_android_graphics_Bitmap), 
44. REG_JNI(register_android_graphics_BitmapFactory), 
45. REG_JNI(register_android_graphics_BitmapRegionDecoder), 
46. REG_JNI(register_android_graphics_Camera), 
47. REG_JNI(register_android_graphics_CreateJavaOutputStreamAdaptor), 
48. REG_JNI(register_android_graphics_Canvas), 
49. REG_JNI(register_android_graphics_ColorFilter), 
50. REG_JNI(register_android_graphics_DrawFilter), 
51. REG_JNI(register_android_graphics_Interpolator), 
52. REG_JNI(register_android_graphics_LayerRasterizer), 
53. REG_JNI(register_android_graphics_MaskFilter), 
54. REG_JNI(register_android_graphics_Matrix), 
55. REG_JNI(register_android_graphics_Movie), 
56. REG_JNI(register_android_graphics_NinePatch), 
57. REG_JNI(register_android_graphics_Paint), 
58. REG_JNI(register_android_graphics_Path), 
59. REG_JNI(register_android_graphics_PathMeasure), 
60. REG_JNI(register_android_graphics_PathEffect), 
61. REG_JNI(register_android_graphics_Picture), 
62. REG_JNI(register_android_graphics_PorterDuff), 
63. REG_JNI(register_android_graphics_Rasterizer), 
64. REG_JNI(register_android_graphics_Region), 
65. REG_JNI(register_android_graphics_Shader), 
66. REG_JNI(register_android_graphics_SurfaceTexture), 
67. REG_JNI(register_android_graphics_Typeface), 
68. REG_JNI(register_android_graphics_Xfermode), 
69. REG_JNI(register_android_graphics_YuvImage), 
70. REG_JNI(register_android_graphics_pdf_PdfDocument), 
71.  
72. REG_JNI(register_android_database_CursorWindow), 
73. REG_JNI(register_android_database_SQLiteConnection), 
74. REG_JNI(register_android_database_SQLiteGlobal), 
75. REG_JNI(register_android_database_SQLiteDebug), 
76. REG_JNI(register_android_os_Debug), 
77. REG_JNI(register_android_os_FileObserver), 
78. REG_JNI(register_android_os_MessageQueue), 
79. REG_JNI(register_android_os_SELinux), 
80. REG_JNI(register_android_os_Trace), 
81. REG_JNI(register_android_os_UEventObserver), 
82. REG_JNI(register_android_net_LocalSocketImpl), 
83. REG_JNI(register_android_net_NetworkUtils), 
84. REG_JNI(register_android_net_TrafficStats), 
85. REG_JNI(register_android_net_wifi_WifiNative), 
86. REG_JNI(register_android_os_MemoryFile), 
87. REG_JNI(register_com_android_internal_os_ZygoteInit), 
88. REG_JNI(register_android_hardware_Camera), 
89. REG_JNI(register_android_hardware_camera2_CameraMetadata), 
90. REG_JNI(register_android_hardware_SensorManager), 
91. REG_JNI(register_android_hardware_SerialPort), 
92. REG_JNI(register_android_hardware_UsbDevice), 
93. REG_JNI(register_android_hardware_UsbDeviceConnection), 
94. REG_JNI(register_android_hardware_UsbRequest), 
95. REG_JNI(register_android_media_AudioRecord), 
96. REG_JNI(register_android_media_AudioSystem), 
97. REG_JNI(register_android_media_AudioTrack), 
98. REG_JNI(register_android_media_JetPlayer), 
99. REG_JNI(register_android_media_RemoteDisplay), 
100. REG_JNI(register_android_media_ToneGenerator), 
101.  
102. REG_JNI(register_android_opengl_classes), 
103. REG_JNI(register_android_server_NetworkManagementSocketTagger), 
104. REG_JNI(register_android_server_Watchdog), 
105. REG_JNI(register_android_ddm_DdmHandleNativeHeap), 
106. REG_JNI(register_android_backup_BackupDataInput), 
107. REG_JNI(register_android_backup_BackupDataOutput), 
108. REG_JNI(register_android_backup_FileBackupHelperBase), 
109. REG_JNI(register_android_backup_BackupHelperDispatcher), 
110. REG_JNI(register_android_app_backup_FullBackup), 
111. REG_JNI(register_android_app_ActivityThread), 
112. REG_JNI(register_android_app_NativeActivity), 
113. REG_JNI(register_android_view_InputChannel), 
114. REG_JNI(register_android_view_InputEventReceiver), 
115. REG_JNI(register_android_view_InputEventSender), 
116. REG_JNI(register_android_view_InputQueue), 
117. REG_JNI(register_android_view_KeyEvent), 
118. REG_JNI(register_android_view_MotionEvent), 
119. REG_JNI(register_android_view_PointerIcon), 
120. REG_JNI(register_android_view_VelocityTracker), 
121.  
122. REG_JNI(register_android_content_res_ObbScanner), 
123. REG_JNI(register_android_content_res_Configuration), 
124.  
125. REG_JNI(register_android_animation_PropertyValuesHolder), 
126. REG_JNI(register_com_android_internal_content_NativeLibraryHelper), 
127. REG_JNI(register_com_android_internal_net_NetworkStatsFactory), 
128. }; 
129.  
130. #ifdef NDEBUG 
131. #define REG_JNI(name) {name} 
132. struct RegJNIRec { 
133. int (*mProc)(JNIEnv*); 
134. }; 
135. #else 
136. #define REG_JNI(name) {name, #name} 
137. struct RegJNIRec { 
138. int (*mProc)(JNIEnv*); 
139. const char* mName; 
140. }; 
141. #endif 

可以看到，REG_JNI是一個宏，宏里面包括的就是那個參數為JNIEnv*,返回值為int的函數指針mProc，我們以register_android_debug_JNITest為例，源碼位置為/frameworks/base/core/jni/android_debug_JNITest.cpp：

1. #define NELEM(x) (sizeof(x)/sizeof(*(x))) 
2.  
3. int register_android_debug_JNITest(JNIEnv* env) 
4. { 
5. return jniRegisterNativeMethods(env, "android/debug/JNITest", gMethods, NELEM(gMethods)); 
6. } 

可以看到，mProc其實就是為Java類注冊JNI函數。

進入JAVA世界

可以看到CallStaticVoidMethod最終將調用com.android.internal.os.ZygoteInit的main函數，下面就來看一下這個Java世界的入口函數。源碼位置：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java，源碼如下：

1. public static void main(String argv[]) 
2. { 
3. try { 
4. SamplingProfilerIntegration.start(); 
5.  
6. // 1. 注冊zygote用的socket 
7. registerZygoteSocket(); 
8. EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START, SystemClock.uptimeMillis()); 
9.  
10. // 2. 預加載類和資源 
11. preload(); 
12. EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END, SystemClock.uptimeMillis()); 
13.  
14. SamplingProfilerIntegration.writeZygoteSnapshot(); 
15.  
16. // 強制執行一次垃圾收集 
17. gc(); 
18.  
19. Trace.setTracingEnabled(false); 
20.  
21. if (argv.length != 2) { 
22. throw new RuntimeException(argv[0] + USAGE_STRING); 
23. } 
24.  
25. if (argv[1].equals("start-system-server")) { 
26. // 3. 啟動system-server 
27. startSystemServer(); 
28. } else if (!argv[1].equals("")) { 
29. throw new RuntimeException(argv[0] + USAGE_STRING); 
30. } 
31.  
32. Log.i(TAG, "Accepting command socket connections"); 
33.  
34. // 4. 進入請求應答模式 
35. runSelectLoop(); 
36. closeServerSocket(); 
37.  
38. } catch(MethodAndArgsCaller caller) { 
39. caller.run(); 
40. } catch(RuntimeException ex) { 
41. Log.e(TAG, "Zygote died with exception", ex); 
42. closeServerSocket(); 
43. throw ex; 
44. } 
45. } 

上述代碼中有5個重要的點，我已經通過標號標記出來了，接下來我們分別分析一下這5點函數的具體實現。

建立IPC通信服務端——registerZygoteSocket

zygote及系統中其他程序的通信沒有使用Binder，而是采用了基于AF_UNIX類型的socket。registerZygoteSocket函數的使命正是建立這個Socket，實現代碼如下：

1. private static void registerZygoteSocket() 
2. { 
3. if (sServerSocket == null) { 
4. int fileDesc; 
5. try { 
6. String env = System.getenv(ANDROID_SOCKET_ENV); 
7. fileDesc = Integer.parseInt(env); 
8. } catch (RuntimeException ex) { 
9. throw new RuntimeException(ANDROID_SOCKET_ENV + " unset or invalid", ex); 
10. } 
11.  
12. try {  
13. sServerSocket = new LocalServerSocket(createFileDescriptor(fileDesc)); 
14. } catch(IOException ex) {  
15. throw new RuntimeException("Error binding to local socket '" + fileDesc + "'", ex); 
16. } 
17. } 
18. } 
19.  
20. public class LocalServerSocket { 
21. private final LocalSocketImpl impl; 
22. private final LocalSocketAddress localAddress; 
23.  
24. private static final int LISTEN_BACKLOG = 50; 
25.  
26. /** 
27. * Create a LocalServerSocket from a file descriptor that's already 
28. * been created and bound. listen() will be called immediately on it. 
29. * Used for cases where file descriptors are passed in via environment 
30. * variables. 
31. */ 
32. public LocalServerSocket(FileDescriptor fd) throws IOException { 
33. impl = new LocalSocketImpl(fd); 
34. impl.listen(LISTEN_BACKLOG); 
35. localAddress = impl.getSockAddress(); 
36. } 
37. } 

registerZygoteSocket很簡單，就是創建一個服務端的socket。

預加載類和資源——preload

我們先來看一下preload函數實現：

1. static void preload() 
2. { 
3. preloadClasses(); 
4. preloadResources(); 
5. preloadOpenGL(); 
6. } 

preload函數里面分別調用了三個預加載函數，我們分別來分析一下這幾個函數的實現。

首先是preloadClasses，函數實現如下：

1. private static final int UNPRIVILEGED_UID = 9999; 
2. private static final int UNPRIVILEGED_GID = 9999; 
3.  
4. private static final int ROOT_UID = 0; 
5. private static final int ROOT_GID = 0; 
6.  
7. private static void preloadClasses() 
8. { 
9. final VMRuntime runtime = VMRuntime.getRuntime(); 
10.  
11. InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream(PRELOADED_CLASSES); 
12. if (is == null) { 
13. Log.e(TAG, "Couldn't find " + PRELOADED_CLASSES + "."); 
14. } else { 
15. Log.i(TAG, "Preloading classes..."); 
16. long startTime = SystemClock.uptimeMillis(); 
17.  
18. setEffectiveGroup(UNPRIVILEGED_GID); 
19. setEffectiveGroup(UNPRIVILEGED_UID); 
20.  
21. float defaultUtilization = runtime.getTargetHeapUtilization(); 
22. runtime.setTargetHeapUtilization(0.8f); 
23.  
24. System.gc(); 
25. runtime.runFinalizationSync(); 
26. Debug.startAllocCounting(); 
27.  
28. try { 
29. // 創建一個緩沖區為256字符的輸入流 
30. BufferedReader br = new BufferdReader(new InputStreamReader(is), 256); 
31. int count = 0; 
32. String line; 
33. while ((line = br.readLine()) != null) { 
34. // skip comments and blank lines. 
35. line = line.trim(); 
36. if (line.startsWith("#") || line.equals("")) { 
37. continue; 
38. } 
39.  
40. try { 
41. if (false) { 
42. Log.v(TAG, "Preloading " + line + "..."); 
43. } 
44. Class.forName(line); 
45. count ++; 
46. } catch (ClassNotFoundException e) { 
47. Log.w(TAG, "Class not found for preloading: " + line); 
48. } catch (UnsatisfiedLinkError e) { 
49. Log.w(TAG, "Problem preloading " + line + ": " + e); 
50. } catch(Throwable t) { 
51. Log.e(TAG, "Error preloading " + line + ".", t); 
52. } 
53. } 
54. Log.i(TAG, "...preloaded " + count + " classes in " + (SystemClock.uptimeMillis()-startTime) + "ms."); 
55. } catch (IOException e) { 
56. Log.e(TAG, "Error reading " + PRELOADED_CLASSES + ".", e); 
57. } finally { 
58. IoUtils.closeQuietly(is); 
59. runtime.setTargetHeapUtilization(defaultUtilization); 
60.  
61. runtime.preloadDexCaches(); 
62. Debug.stopAllocCounting(); 
63.  
64. setEffectiveUser(ROOT_UID); 
65. setEffectiveGroup(ROOT_GID); 
66. } 
67. } 
68. } 

preloadClasses看起來很簡單，但是實際上它有很多的類需要加載。可以查看一下/frameworks/base/preloaded-classes文件，這里面都是需要預加載的類。

接下來，分析一下preloadResources函數的源碼：

1. private static final boolean PRELOAD_RESOURCES = true; 
2. private static void preloadResources() 
3. { 
4. final VMRuntime runtime = VMRuntime.getRuntime(); 
5. Debug.startAllocCounting(); 
6.  
7. try { 
8. System.gc(); 
9. runtime.runFinalizationSync(); 
10. mResources = Resources.getSystem(); 
11. mResources.startPreloading(); 
12. if (PRELOAD_RESOURCES) { 
13. Log.i(TAG, "Preloading resources..."); 
14.  
15. long startTime = SystemClock.uptimeMillis(); 
16. TypedArray ar = mResources.obtainTypedArray(com.android.internal.R.array.preloaded_drawables); 
17. int N = preloadDrawables(runtime, ar); 
18. ar.recycle(); 
19. Log.i(TAG, "...preloaded " + N + " resources in " + (SystemClock.uptimeMillis()-startTime) + "ms."); 
20.  
21. startTime = SystemClock.uptimeMillis(); 
22. ar = mResources.obtainTypedArray(com.android.internal.R.array.preloaded_color_state_lists); 
23. N = preloadColorstateLists(runtime, ar); 
24. ar.recycle(); 
25. Log.i(TAG, "...preloaded " + N + " resources in " + (SystemClock.uptimeMillis() - startTime) + "ms."); 
26. } 
27. mResources.finishPreloading(); 
28. } catch (RuntimeException e) { 
29. Log.w(TAG, "Failure preloading resources", e); 
30. } finally { 
31. Debug.stopAllocCounting(); 
32. } 
33. } 

接下來，是預加載OpenGL。源碼如下：

1. private static void preloadOpenGL() 
2. { 
3. if (!SystemProperties.getBoolean(PROPERTY_DISABLE_OPENGL_PRELOADING, false)) { 
4. EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY); 
5. } 
6. } 

啟動system_server

現在我們要分析第三個關鍵點：startSystemServer。這個函數會創建java世界中系統Service所駐留的進程system_server，該進程是framework的核心。如何system_server掛掉，會導致zygote自殺。我們來看一下startSystemServer()實現源碼。

1. /** 
2. * Prepare the arguments and fork for the system server process. 
3. */ 
4. private static boolean startSystemServer() throws MethodAndArgsCaller, RuntimeException 
5. { 
6. long capabilities = posixCapabilitiesAsBits( 
7. OsConstants.CAP_KILL, 
8. OsConstants.CAP_NET_ADMIN, 
9. OsConstants.CAP_NET_BIND_SERVICE, 
10. OsConstants.CAP_NET_BROADCAST, 
11. OsConstants.CAP_NET_RAW, 
12. OsConstants.CAP_SYS_MODULE, 
13. OsConstants.CAP_SYS_NICE, 
14. OsConstants.CAP_SYS_RESOURCE, 
15. OsConstants.CAP_SYS_TIME, 
16. OsConstants.CAP_SYS_TTY_CONFIG 
17. ); 
18.  
19. // 設置參數 
20. String args[] = { 
21. "--setuid=1000", 
22. "--setgid=1000", 
23. "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1032,3001,3002,3003,3006,3007", 
24. "--capabilities=" + capabilities + "," + capabilities, 
25. "--runtime-init", 
26. "--nice-name=system_server", // 進程名為system_server 
27. "com.android.server.SystemServer", 
28. }; 
29.  
30. ZygoteConnection.Arguments parsedArgs = null; 
31.  
32. int pid; 
33.  
34. try { 
35. parsedArgs = new ZygoteConnection.Arguments(args); 
36. ZygoteConnection.applyDebuggerSystemProperty(parsedArgs); 
37. ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs); 
38.  
39. /* Request to fork the system server process */ 
40. pid = Zygote.forkSystemServer( 
41. parsedArgs.uid, parsedArgs.gid, 
42. parsedArgs.gids, 
43. parsedArgs.debugFlags, 
44. null, 
45. parsedArgs.permittedCapabilities, 
46. parsedArgs.effectiveCapabilities 
47. ); 
48. } catch (IllegalArgumentException ex) { 
49. throw new RuntimeException(ex); 
50. } 
51.  
52. /* For child process */ 
53. if (pid == 0) { 
54. handleSystemServerProcess(parsedArgs); 
55. } 
56.  
57. return true; 
58. } 

有求必應之等待請求——runSelectLoop

zygote從startSystemServer返回后，將進入第四個關鍵的函數:runSelectLoop。我們來看一下這個函數的實現：

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