标签：des android c class blog code
Zygote本身是一个NATIVE层的应用程序，与驱动、内核无关。前面已经介绍过了，zygote由init进程根据init.rc配置文件创建。其实本质上来说，zygote就是app_process，这个名字在android.mk中指定，但是在运行的时候，app_process通过LINUX下的pctrl系统调用将自己的名字换成了“zygote”，所以通过ps命令就可以看到进程的名字为zygote。Pctrl函数相关信息见：
http://blog.csdn.net/zuokong/article/details/7318154
zygote的原型app_process在App_main.cpp中：
|
int main(int argc, char* const argv[]) { // These are global variables in ProcessState.cpp mArgC = argc; mArgV = argv;
mArgLen = 0; for (int i=0; i<argc; i++) { mArgLen += strlen(argv[i]) + 1; } mArgLen--;
AppRuntime runtime; const char* argv0 = argv[0]; …… /*将参数加入到JAVAVM中作为其参数选项*/ int i = runtime.addVmArguments(argc, argv);
// Parse runtime arguments. Stop at first unrecognized option. bool zygote = false; bool startSystemServer = false; bool application = false; const char* parentDir = NULL; const char* niceName = NULL; const char* className = NULL; while (i < argc) { const char* arg = argv[i++]; if (!parentDir) { parentDir = arg; } else if (strcmp(arg, "--zygote") == 0) { zygote = true; niceName = "zygote"; } else if (strcmp(arg, "--start-system-server") == 0) { startSystemServer = true; } else if (strcmp(arg, "--application") == 0) { application = true; } else if (strncmp(arg, "--nice-name=", 12) == 0) { niceName = arg + 12; } else { className = arg; break; } } //这就是前面说的换名把戏的实现函数 if (niceName && *niceName) { setArgv0(argv0, niceName); set_process_name(niceName); } //设置runtime的mParentDir为/sysem/bin runtime.mParentDir = parentDir; if (zygote) { //★这是关键函数，怎个zygote的主要功能都由此函数启动！ runtime.start("com.android.internal.os.ZygoteInit", startSystemServer ? "start-system-server" : ""); } else if (className) { // Remainder of args get passed to startup class main() runtime.mClassName = className; runtime.mArgC = argc - i; runtime.mArgV = argv + i; runtime.start("com.android.internal.os.RuntimeInit", application ? "application" : "tool"); } 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; } } |
AppRuntime是一个类，该类的声明和实现都在APP_main.cpp中，该类派生至AndroidRuntime类。
AppRuntime重载了onStarted, onZygoteInit, onExit函数。
1.1节中说道zygote的main函数中调用了AppRuntime.start函数，下面来详细分析下这个函数的功能：
|
1) 获取环境变量ANDROID_ROOT的值，赋给rootDir，如果该值为null，就新增该变量，并将其值设置为”/system”。 2) ★创建虚拟机： if (startVm(&mJavaVM, &env) != 0) { return; } 3) ★注册JNI函数： startReg(env)； 4) 构建一个String数组，这个数组含有两个元素：classname, option。这个数组用于后面第五步的main函数的参数！ stringClass = env->FindClass("java/lang/String"); assert(stringClass != NULL); //string strArray[] = new String[2]; strArray = env->NewObjectArray(2, stringClass, NULL); assert(strArray != NULL); classNameStr = env->NewStringUTF(className); assert(classNameStr != NULL); //设置第一个元素值为“com.android.internal.os.zygoteInit” env->SetObjectArrayElement(strArray, 0, classNameStr); optionsStr = env->NewStringUTF(options); //设置第二个元素值为“start-system-server”！ env->SetObjectArrayElement(strArray, 1, optionsStr); 5) ★开始虚拟机，此线程就变为虚拟机的主线程，除非虚拟机退出，否则这个线程是不会返回的： ①将前面的com.android.internal.os.zygoteInit转换为斜线的形式，这样就符合jni函数的规范了，以后我们均简称其为zygoteInit类： char* slashClassName = toSlashClassName(className); ②调用该类的main(strings)函数，此函数的参数就是前面说的string数组。 /*在调用zygoteInit的main函数后，zygote便进入了java世界！所以说zygote是android系统中JAVA世界的鼻祖！*/ char* slashClassName = toSlashClassName(className); jclass startClass = env->FindClass(slashClassName); 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"); if (startMeth == NULL) { ALOGE("JavaVM unable to find main() in ‘%s‘\n", className); /* keep going */ } else { env->CallStaticVoidMethod(startClass, startMeth, strArray);
……. |
通过上面对app_runtime的start函数的分析，我们发现了三个关键点：2、3、5。它们共同创建了整个Android的JAVA世界，下面分别对它们三个进行详细分析。
该函数就是调用JNI的虚拟机创建函数，但是创建虚拟机时的一些参数却是在此函数中确定的，详细代码在base/core/jni/Android_Runtime.cpp中：
|
/*此函数的绝大部分代码都是设置虚拟机的参数，这里只分析其中的两个。*/ /*下面的代码是用来设置JNI check选项的，JNIcheck就是NATIVE层调用JNI函数时，系统所做的一些检查工作。如，调用NEWUTFString函数时，系统会检测传入的字符串是否满足UTF-8编码格式。它还能检测资源是否被正确释放，但这个选项比较耗时，只有在eng版的系统里面才有，正式发布的user版是关闭了此功能的。下面几句代码就是有系统属性来控制是否使用JNI check。*/ property_get("dalvik.vm.checkjni", propBuf, ""); if (strcmp(propBuf, "true") == 0) { checkJni = true; } else if (strcmp(propBuf, "false") != 0) { /* property is neither true nor false; fall back on kernel parameter */ property_get("ro.kernel.android.checkjni", propBuf, ""); if (propBuf[0] == ‘1‘) { checkJni = true; } } …… /*开始设置虚拟机的堆栈起始大小和最大大小，默认起始大小是4MB最大大小是16MB，不过绝大多数厂商都会更改这个值*/ strcpy(heapstartsizeOptsBuf, "-Xms"); property_get("dalvik.vm.heapstartsize", heapstartsizeOptsBuf+4, "4m"); opt.optionString = heapstartsizeOptsBuf; mOptions.add(opt); strcpy(heapsizeOptsBuf, "-Xmx"); property_get("dalvik.vm.heapsize", heapsizeOptsBuf+4, "16m"); opt.optionString = heapsizeOptsBuf; mOptions.add(opt); …… /*最后调用JNI_CreateJavaVM 函数创建虚拟机,pEnv返回当前线程的JNIEnv，从这里就可以了解到VM是对进程而言的，JNIEnv是对线程而言的*/ if (JNI_CreateJavaVM(pJavaVM, pEnv, &initArgs) < 0) { ALOGE("JNI_CreateJavaVM failed\n"); goto bail; } |
上一节介绍了如何创建虚拟机，本节就介绍如何给这个虚拟机注册JNI函数。因为后续的JAVA世界用到的一些函数是采用NATIVE方式实现的，所以才必须提前注册这些JNI函数。详细代码同样在AndroidRuntime.cpp中：
|
/*static*/ int AndroidRuntime::startReg(JNIEnv* env) { /* * 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.) */ /* 设置Thread类的线程创建函数为javaCreateThreadEtc(这其实是一个hook函数)，此函数的具体作用将在后面进行详细分析 */ 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); //注册JNI函数，gRegJNI是一个全局大数组，每个元素对应了一个JNI注册方法。 if (register_jni_procs(gRegJNI, NELEM(gRegJNI), env) < 0) { env->PopLocalFrame(NULL); return -1; } env->PopLocalFrame(NULL); //这句话听说是码农休闲时的小把戏，可以称为IT界的文物~ //createJavaThread("fubar", quickTest, (void*) "hello");
return 0; } |
下面再来看看register_jni_procs函数的详细代码：
|
static int register_jni_procs(const RegJNIRec array[], size_t count, JNIEnv* env) { for (size_t i = 0; i < count; i++) { if (array[i].mProc(env) < 0) {//此函数仅仅是一个封装，调用数组元素的mproc函数，完成对应的JNI注册 #ifndef NDEBUG ALOGD("----------!!! %s failed to load\n", array[i].mName); #endif return -1; } } return 0; } |
上面提到了gRegJNI全局数组，该数组元素调用mProc函数，那么它们到底是什么呢？
|
static const RegJNIRec gRegJNI[] = { REG_JNI(register_com_android_internal_os_RuntimeInit), REG_JNI(register_android_os_SystemClock), REG_JNI(register_android_util_EventLog), REG_JNI(register_android_util_Log), REG_JNI(register_android_util_FloatMath), REG_JNI(register_android_text_format_Time), …. 约有100项，每一项的括号里面的参数name对应一个函数name(env) } REG_JNI是一个宏，宏里面包含的就是那个mProc函数。 #ifdef NDEBUG #define REG_JNI(name) { name } struct RegJNIRec { int (*mProc)(JNIEnv*); }; #else #define REG_JNI(name) { name, #name } struct RegJNIRec { int (*mProc)(JNIEnv*); const char* mName; }; #endif 这个宏的意思就是，当我们调用gRegJNI[i].mProc(env)时，真正执行的函数就是name_i (env)，这里为了方便就这样定义了，这个小技巧值得学习啊。 |
至此，我们已经分析了startVM, StartReg，了解了虚拟机的创建，学习了JNI函数的注册，下面就调用zygoteInit的main函数，进入java世界了！
Java世界的入口函数就是zygoteInit的main函数，下面看看这个main函数的具体功能(ps：后面的代码都是java代码了~)。
|
public static void main(String argv[]) { try { // Start profiling the zygote initialization. SamplingProfilerIntegration.start(); //★key1注册zygote用的socket registerZygoteSocket(); EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START, SystemClock.uptimeMillis()); preload(); //★key2预加载类资源等 /* static void preload() { preloadClasses(); preloadResources(); preloadOpenGL(); } */ EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END, SystemClock.uptimeMillis()); // Finish profiling the zygote initialization. SamplingProfilerIntegration.writeZygoteSnapshot(); //强制执行一次垃圾回收 gc(); // If requested, start system server directly from Zygote if (argv.length != 2) { throw new RuntimeException(argv[0] + USAGE_STRING); } if (argv[1].equals("start-system-server")) { startSystemServer(); //★key3我们传入的参数是满足if的,所以调用此函数启动system_server进程 } else if (!argv[1].equals("")) { throw new RuntimeException(argv[0] + USAGE_STRING); } Log.i(TAG, "Accepting command socket connections"); runSelectLoop();//★key4 zygote调用这个函数 closeServerSocket(); } catch (MethodAndArgsCaller caller) { caller.run(); //★key5 很重要的caller run函数，以后分析 } catch (RuntimeException ex) { Log.e(TAG, "Zygote died with exception", ex); closeServerSocket(); throw ex; } } |
在这个main函数中，列举了5大关键点，下面一一进行分析。
1、建立IPC通信服务端:registerZygoteSocket
Zygote及系统中其他程序之间的通讯并没有使用Binder，而是采用了基于AF_UNIX类型的Socket。registerZygoteSocket的工作就是建立这个socket。
|
private static void registerZygoteSocket() { if (sServerSocket == null) { int fileDesc; try { /*从环境变量中获取socket的fd，回想一下zygote是如何启动的：在init进程的main函数中有一个execve函数，该函数的第三个参数就是环境变量*/ String env = System.getenv(ANDROID_SOCKET_ENV); fileDesc = Integer.parseInt(env); } catch (RuntimeException ex) { throw new RuntimeException( ANDROID_SOCKET_ENV + " unset or invalid", ex); } try { //创建服务端socket，这个socket将listen并accept Client sServerSocket = new LocalServerSocket( createFileDescriptor(fileDesc)); } catch (IOException ex) { throw new RuntimeException( "Error binding to local socket ‘" + fileDesc + "‘", ex); } } } |
registerZygoteSocket很简单，就是创建一个socket服务器。不过我们应当思考一下：
①谁是客户端？
②服务端如何处理来自客户端的请求？
2、预加载类和资源
这里主要分析preloadClasses和preloadResources函数。
首先来看preloadClasses函数：
①预加载类的信息存储在PRELOADED_CLASSES变量中，它的值为”preloaded_classes”。这是一个文件的名字。意思就是预加载类的信息存储在这个文件中！
②读取该文件的每一行，再通过JAVA反射来加载类，每一行中存储的就是预加载类的类名。
Class.forName(line);
③一些扫尾工作。
Preloadclasses看起来很简单，但其实它要加载1268个类！！！这是相当耗时的，这也是Android系统启动慢的原因之一。Preload-class文件由frame/base/tools/preload工具生成，它会判断每个类的加载时间是否大于1250微秒，超过这个时间的话就会被写到这个文件中，再由zygote预加载。详细信息可以参考preload工具的说明。
至于preloadResources，它与preloadClasses类似，它主要加载frameword-res.apk中的资源——在UI编程中常用到的com.android.R.xxx是系统默认资源，它们就是由zygote在这里加载的。
3、启动system_server
现在开始分析第三个关键函数startSystemServer。这个函数会创建JAVA世界中系统server所驻留的进程system_server，该进程是framework的核心。
|
private static boolean startSystemServer() throws MethodAndArgsCaller, RuntimeException { /** Hardcoded command line to start the system server */ String args[] = { "--setuid=1000",Class.forName(line); "--setgid=1000", "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,3001,3002,3003", "--capabilities=130104352,130104352", "--runtime-init", "--nice-name=system_server", "com.android.server.SystemServer", }; ZygoteConnection.Arguments parsedArgs = null; int pid; try { //将args转换成Arguments类对象 parsedArgs = new ZygoteConnection.Arguments(args); int debugFlags = parsedArgs.debugFlags; if ("1".equals(SystemProperties.get("ro.debuggable"))) debugFlags |= Zygote.DEBUG_ENABLE_DEBUGGER; /*fork一个子进程，这个子进程就是system_server进程 */ pid = Zygote.forkSystemServer( parsedArgs.uid, parsedArgs.gid, parsedArgs.gids, debugFlags, null); } catch (IllegalArgumentException ex) { throw new RuntimeException(ex); } /** For child process */ if (pid == 0) { handleSystemServerProcess(parsedArgs); //system_server进程的工作。 } return true; } |
handleSystemServerProcess的详细代码如下：
|
private static void handleSystemServerProcess( ZygoteConnection.Arguments parsedArgs) throws ZygoteInit.MethodAndArgsCaller { /*首先设置兼容性*/ if (parsedArgs.uid != 0) { try { setCapabilities(parsedArgs.permittedCapabilities, parsedArgs.effectiveCapabilities); } catch (IOException ex) { Log.e(TAG, "Error setting capabilities", ex); } } //然后关闭该服务的socket closeServerSocket();
/** * 将主要的参数传递给SystemServer. * "--nice-name=system_server com.android.server.SystemServer" */ RuntimeInit.zygoteInit(parsedArgs.remainingArgs); } |
从上面的代码可以看出，zygote进行了一次fork，创建了一个子进程system_server进程(代码中的zygote.forkSystemServer)，该进程的具体作用后面再讲，下面继续分析zygote进程。
4、runSelectLoop分析
当zygote从startSystemServer返回后，就进入第四个关键函数：runSelectLoop。
回想在前面的第一个关键点registerZygoteSocket中注册了一个用于IPC的socket，并提出了两个问题，第二个问题就是：服务端如何处理请求。答案就在这个函数中：
|
private static void runSelectLoop() throws MethodAndArgsCaller { ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>(); ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>(); FileDescriptor[] fdArray = new FileDescriptor[4]; /* sServerSocket 是我们在前面的registerZygoteSocket中建立的socket*/ fds.add(sServerSocket.getFileDescriptor()); peers.add(null); int loopCount = GC_LOOP_COUNT; while (true) { int index; if (loopCount <= 0) { gc(); loopCount = GC_LOOP_COUNT; } else { loopCount--; } try { fdArray = fds.toArray(fdArray); /* selectReadable 是一个NATIVE函数，使用多路复用I/O模型。 当有客户端连接或有数据时，该函数就返回。新的客户端连接上返回0，已连接上的客户端发送数据则返回>0，错误返回-1*/ index = selectReadable(fdArray); } catch (IOException ex) { throw new RuntimeException("Error in select()", ex); }
if (index < 0) { throw new RuntimeException("Error in select()"); } else if (index == 0) { /*有一个客户端连接上。注意，客户端在zygote的代表是zygoteConnection*/ ZygoteConnection newPeer = acceptCommandPeer(); peers.add(newPeer); fds.add(newPeer.getFileDesciptor()); } else { boolean done; /*客户端发送了请求，peers.get返回zygoteConnection类对象，然后调用该类的runOnce函数来处理客户端请求*/ done = peers.get(index).runOnce();
if (done) { /*表示客户端的请求已经得到解决，服务器就删除该连接*/ peers.remove(index); fds.remove(index); } } } }
|
总结runSelectLoop：
①处理客户端的连接和请求。客户端在zygote中使用zygoteConnection对象表示。
②客户端的请求有zygoteconnection的runOnce函数处理。该函数实现代码较为复杂，主要原理是：从socket命令行里面读取一个开始命令。如果读取成功，就fork一个子进程并在这个子进程中抛出zygoteInit.MethodAndArgsCaller异常，而父进程中就正常返回；如果读取失败，那么就不会fork子进程，而是log出错误消息。至于父进程的返回值也有两种：如果在socket命令中读取到了一个EOF标志，就返回true值，如果还有命令可以读取，就返回false值——这个返回值就是标记客户端请求是否完成的~
Zygote是Android系统中创建JAVA世界的盘古——它创建了第一个JAVA虚拟机；它也是女娲——它成功的fork了framework的核心system_server进程。现在回顾一下Zygote创建JAVA世界的步骤：
①创建AppRuntime对象，并调用它的start方法。此后的活动均由AppRuntime控制。
②调用startVM创建虚拟机，然后调用startReg来注册JNI函数。
③通过JNI调用com.android.internal.os.ZygoteInit类的main函数，从此进入了JAVA世界。只不过这个世界刚创造，里面什么东西都没有。
④调用registerZygoteSocket函数，这个函数相应子孙后代的请求，同时zygote调用preloadClass,preloadResource,preloadOpenGL为JAVA世界添砖加瓦。
⑤zygote觉得自己的工作量有点大，就fork了一个进程system_server来为java世界服务。
⑥zygote完成了Java世界的初创工作，它有点累了。以后的工作就由runSelectLoop函数来处理，zygote睡觉去了。
⑦以后的日子：zygote随时守护在我们的周围，当接收到子孙后代的请求时，它随时醒来，为它们工作。
标签：des android c class blog code
原文地址：http://www.cnblogs.com/wanyuanchun/p/3746658.html
