码迷，mamicode.com
首页 > 移动开发 > 详细

Android4.4的zygote进程（下）

时间：2016-09-25 22:15:46      阅读：362      评论：0      收藏：0      [点我收藏+]

标签：

3.2.4启动Android系统服务——startSystemServer()

接下来就是启动Android的重头戏了，此时ZygoteInit的main()函数会调用startSystemServer()，该函数用于启动整个Android系统的系统服务。其大体做法是先fork一个子进程，然后在子进程中做一些初始化动作，继而执行SystemServer类的main()静态函数。需要注意的是，startSystemServer()并不是在函数体内直接调用Java类的main()函数的，而是通过抛异常的方式，在startSystemServer()之外加以处理的。

startSystemServer()的代码如下：

 

[java] view plain copy
 
  1. private static boolean startSystemServer()  
  2.         throws MethodAndArgsCaller, RuntimeException   
  3. {  
  4.     . . . . . .  
  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,1021,1032,  
  10.                         3001,3002,3003,3006,3007",  
  11.         "--capabilities=" + capabilities + "," + capabilities,  
  12.         "--runtime-init",  
  13.         "--nice-name=system_server",  
  14.         "com.android.server.SystemServer",  
  15.     };  
  16.     ZygoteConnection.Arguments parsedArgs = null;  
  17.     int pid;  
  18.     try {  
  19.         parsedArgs = new ZygoteConnection.Arguments(args);  
  20.         ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);  
  21.         ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);  
  22.   
  23.         // fork出系统服务对应的进程  
  24.         pid = Zygote.forkSystemServer(parsedArgs.uid, parsedArgs.gid,  
  25.                                             parsedArgs.gids, parsedArgs.debugFlags, null,  
  26.                                             parsedArgs.permittedCapabilities,  
  27.                                             parsedArgs.effectiveCapabilities);  
  28.     } catch (IllegalArgumentException ex) {  
  29.         throw new RuntimeException(ex);  
  30.     }  
  31.   
  32.     // 对新fork出的系统进程，执行handleSystemServerProcess()  
  33.     if (pid == 0) {  
  34.         handleSystemServerProcess(parsedArgs);  
  35.     }  
  36.     return true;  
  37. }  

 

 
 args[]中的字符串  对应
 "--setuid=1000"  parsedArgs.uid
 "--setgid=1000"  parsedArgs.gid

 "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,
1009,1010,1018,1021,1032,3001,3002,3003,3006,3007"

  parsedArgs.gids
 "--capabilities=" + capabilities + "," + capabilities  capabilitiesSpecified = true;
permittedCapabilities = Long.decode(capStrings[0]);
effectiveCapabilites = Long.decode(capString[1]);
 "--runtime-init"  parsedArgs.runtimeInit设为true
 "--nice-name=system_server"  parsedArgs.niceName
 "com.android.server.SystemServer"  parsedArgs.remainingArgs

 

3.2.4.1Zygote.forkSystemServer()

Zygote.forkSystemServer()的代码如下：
【libcore/dalvik/src/main/java/dalvik/system/Zygote.java】

 

[java] view plain copy
 
  1. public static int forkSystemServer(int uid, int gid, int[] gids, int debugFlags,  
  2.         int[][] rlimits, long permittedCapabilities, long effectiveCapabilities)   
  3. {  
  4.     preFork();  
  5.     int pid = nativeForkSystemServer(uid, gid, gids, debugFlags, rlimits,   
  6.                                      permittedCapabilities, effectiveCapabilities);  
  7.     postFork();  
  8.     return pid;  
  9. }  

 

其中的nativeForkSystemServer()是个native成员函数，其对应的C++层函数为Dalvik_dalvik_system_Zygote_forkSystemServer()。

【dalvik/vm/native/dalvik_system_Zygote.cpp】

 

[cpp] view plain copy
 
  1. const DalvikNativeMethod dvm_dalvik_system_Zygote[] = {  
  2.     { "nativeFork", "()I",  
  3.       Dalvik_dalvik_system_Zygote_fork },  
  4.     { "nativeForkAndSpecialize", "(II[II[[IILjava/lang/String;Ljava/lang/String;)I",  
  5.       Dalvik_dalvik_system_Zygote_forkAndSpecialize },  
  6.     { "nativeForkSystemServer", "(II[II[[IJJ)I",  
  7.       Dalvik_dalvik_system_Zygote_forkSystemServer },  
  8.     { NULL, NULL, NULL },  
  9. };  

 

 
[cpp] view plain copy
 
  1. static void Dalvik_dalvik_system_Zygote_forkSystemServer(  
  2.         const u4* args, JValue* pResult)  
  3. {  
  4.     pid_t pid;  
  5.     pid = forkAndSpecializeCommon(args, true);  
  6.   
  7.     if (pid > 0) {  
  8.         int status;  
  9.   
  10.         ALOGI("System server process %d has been created", pid);  
  11.         gDvm.systemServerPid = pid;  
  12.         if (waitpid(pid, &status, WNOHANG) == pid) {  
  13.             ALOGE("System server process %d has died. Restarting Zygote!", pid);  
  14.             kill(getpid(), SIGKILL);  
  15.         }  
  16.     }  
  17.     RETURN_INT(pid);  
  18. }  
forkAndSpecializeCommon()内部其实会调用fork()，而后设置gid、uid等信息。

3.2.4.2SystemServer的handleSystemServerProgress()函数

接着，startSystemServer()会在新fork出的子进程中调用handleSystemServerProgress()，让这个新进程成为真正的系统进程（SystemServer进程）。

 

[java] view plain copy
 
  1. // 对新fork出的系统进程，执行handleSystemServerProcess()  
  2. if (pid == 0) {  
  3.     handleSystemServerProcess(parsedArgs);  
  4. }  

 

注意，调用handleSystemServerProcess()时，程序是运行在新fork出的进程中的。handleSystemServerProcess()的代码如下：

【frameworks/base/core/java/com/android/internal/os/ZygoteInit.java】

 

[java] view plain copy
 
  1. private static void handleSystemServerProcess(ZygoteConnection.Arguments parsedArgs)  
  2.                                            throws ZygoteInit.MethodAndArgsCaller   
  3. {  
  4.     closeServerSocket();  
  5.     Libcore.os.umask(S_IRWXG | S_IRWXO);  
  6.   
  7.     if (parsedArgs.niceName != null) {  
  8.         Process.setArgV0(parsedArgs.niceName);  // niceName就是”system_server”  
  9.     }  
  10.   
  11.     if (parsedArgs.invokeWith != null) {  
  12.         WrapperInit.execApplication(parsedArgs.invokeWith,  
  13.                 parsedArgs.niceName, parsedArgs.targetSdkVersion,  
  14.                 null, parsedArgs.remainingArgs);  
  15.     } else {  
  16.         // 此时的remainingArgs就是”com.android.server.SystemServer”  
  17.         RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs);  
  18.     }  
  19. }  

 

 
3.2.4.2.1closeServerSocket()

因为当前已经不是运行在zygote进程里了，所以zygote里的那个监听socket就应该关闭了。这就是closeServerSocket()的意义，其代码如下：

 

[java] view plain copy
 
  1. static void closeServerSocket()   
  2. {  
  3.     try {  
  4.         if (sServerSocket != null) {  
  5.             FileDescriptor fd = sServerSocket.getFileDescriptor();  
  6.             sServerSocket.close();  
  7.             if (fd != null) {  
  8.                 Libcore.os.close(fd);  
  9.             }  
  10.         }  
  11.     } catch (IOException ex) {  
  12.         Log.e(TAG, "Zygote:  error closing sockets", ex);  
  13.     } catch (libcore.io.ErrnoException ex) {  
  14.         Log.e(TAG, "Zygote:  error closing descriptor", ex);  
  15.     }  
  16.     sServerSocket = null;  
  17. }  

 

在handleSystemServerProcess()函数里，parsedArgs.niceName就是“system_server”，而且因为parsedArgs.invokeWith没有指定，所以其值为null，于是程序会走到RuntimeInit.zygoteInit()。
3.2.4.2.2RuntimeInit.zygoteInit()

RuntimeInit.zygoteInit()的代码如下：
【frameworks/base/core/java/com/android/internal/os/RuntimeInit.java】

 

[java] view plain copy
 
  1. public static final void zygoteInit(int targetSdkVersion, String[] argv)  
  2.         throws ZygoteInit.MethodAndArgsCaller   
  3. {  
  4.     if (DEBUG) Slog.d(TAG, "RuntimeInit: Starting application from zygote");  
  5.     redirectLogStreams();  
  6.     commonInit();  
  7.     nativeZygoteInit();  
  8.     applicationInit(targetSdkVersion, argv);  
  9. }  

 

 
3.2.4.2.2.1.调用redirectLogStreams()

首先，在新fork出的系统进程里，需要重新定向系统输出流。

 

[java] view plain copy
 
  1. public static void redirectLogStreams()   
  2. {  
  3.     System.out.close();  
  4.     System.setOut(new AndroidPrintStream(Log.INFO, "System.out"));  
  5.     System.err.close();  
  6.     System.setErr(new AndroidPrintStream(Log.WARN, "System.err"));  
  7. }  

 

 
3.2.4.2.2.2.调用commonInit()

 

[java] view plain copy
 
  1. private static final void commonInit()   
  2. {  
  3.     . . . . . .  
  4.     Thread.setDefaultUncaughtExceptionHandler(new UncaughtHandler());  
  5.   
  6.     TimezoneGetter.setInstance(new TimezoneGetter()   
  7.     . . . . . .  
  8.     . . . . . .  
  9.     String trace = SystemProperties.get("ro.kernel.android.tracing");  
  10.     . . . . . .  
  11.     initialized = true;  
  12. }  

 

当前正处于系统进程的主线程中，可以调用Thread.setDefaultUncaughtExceptionHandler()来设置一个默认的异常处理器，处理程序中的未捕获异常。其他的初始化动作，我们暂不深究。
3.2.4.2.2.3.调用nativeZygoteInit()

接下来调用的nativeZygoteInit()是个JNI函数，在AndroidRuntime.cpp文件中可以看到：
【frameworks/base/core/jni/AndroidRuntime.cpp】

 

[java] view plain copy
 
  1. static JNINativeMethod gMethods[] = {  
  2.     { "nativeFinishInit", "()V",  
  3.         (void*) com_android_internal_os_RuntimeInit_nativeFinishInit },  
  4.     { "nativeZygoteInit", "()V",  
  5.         (void*) com_android_internal_os_RuntimeInit_nativeZygoteInit },  
  6.     { "nativeSetExitWithoutCleanup", "(Z)V",  
  7.         (void*) com_android_internal_os_RuntimeInit_nativeSetExitWithoutCleanup },  
  8. };  

 

nativeZygoteInit()对应的本地函数为com_android_internal_os_RuntimeInit_nativeZygoteInit()。
[java] view plain copy
 
  1. static void com_android_internal_os_RuntimeInit_nativeZygoteInit(JNIEnv* env, jobject clazz)  
  2. {  
  3.     gCurRuntime->onZygoteInit();  
  4. }  
gCurRuntime是C++层的AndroidRuntime类的静态变量。在AndroidRuntime构造之时，

gCurRuntime = this。不过实际调用的onZygoteInit()应该是AndroidRuntime的子类AppRuntime的：
【frameworks/base/cmds/app_process/App_main.cpp】

 

[java] view plain copy
 
  1. class AppRuntime : public AndroidRuntime  
  2. {  
  3.     . . . . . .  
  4.     virtual void onZygoteInit()  
  5.     {  
  6.         // Re-enable tracing now that we‘re no longer in Zygote.  
  7.         atrace_set_tracing_enabled(true);  
  8.   
  9.         sp<ProcessState> proc = ProcessState::self();  
  10.         ALOGV("App process: starting thread pool.\n");  
  11.         proc->startThreadPool();  
  12.     }  

 

里面构造了进程的ProcessState全局对象，而且启动了线程池。

ProcessState对象是典型的单例模式，它的self()函数如下：

 

[java] view plain copy
 
  1. sp<ProcessState> ProcessState::self()  
  2. {  
  3.     Mutex::Autolock _l(gProcessMutex);  
  4.     if (gProcess != NULL) {  
  5.         return gProcess;  
  6.     }  
  7.     gProcess = new ProcessState;  
  8.     return gProcess;  
  9. }  

 

ProcessState对于Binder通信机制而言非常重要，现在system server进程的PrecessState算是初始化完毕了。

我们整理一下思路，画一张startSystemServer()的调用关系图：

 

技术分享

 

接下来我们来讲上图中zygoteInit()调用的最后一行：applicationInit()。

3.2.4.2.2.4.调用applicationInit()

applicationInit()函数的代码如下：
【frameworks/base/core/java/com/android/internal/os/RuntimeInit.java】

[java] view plain copy
 
  1. private static void applicationInit(int targetSdkVersion, String[] argv)  
  2.         throws ZygoteInit.MethodAndArgsCaller   
  3. {  
  4.     nativeSetExitWithoutCleanup(true);  
  5.     VMRuntime.getRuntime().setTargetHeapUtilization(0.75f);  
  6.     VMRuntime.getRuntime().setTargetSdkVersion(targetSdkVersion);  
  7.   
  8.     final Arguments args;  
  9.     try {  
  10.         args = new Arguments(argv);  
  11.     } catch (IllegalArgumentException ex) {  
  12.         Slog.e(TAG, ex.getMessage());  
  13.         return;  
  14.     }  
  15.     invokeStaticMain(args.startClass, args.startArgs);  
  16. }  

其中的invokeStaticMain()一句最为关键，它承担向外抛出“特殊异常”的作用。我们先画一张startSystemServer()的调用关系图：

技术分享

看到了吧，最后一步抛出了异常。这相当于一个“特殊的goto语句”！上面的cl = Class.forName(className)一句，其实加载的就是SystemServer类。这个类名是从前文的parsedArgs.remainingArgs得来的，其值就是“com.android.server.SystemServer”。此处抛出的异常，会被本进程的catch语句接住，在那里才会执行SystemServer类的main()函数。示意图如下：

技术分享

 

如上图所示，新fork出的SystemServer子进程直接跳过了中间那句runSelectLoop()，径直跳转到caller.run()一步了。

当然，父进程Zygote在fork动作后，会退出startSystemServer()函数，并走到runSelectLoop()，从而进入一种循环监听状态，每当Activity Manager Service向它发出“启动新应用进程”的命令时，它又会fork一个子进程，并在子进程里抛出一个异常，这样子进程还是会跳转到catch一句。

我们可以把上面的示意图再丰富一下：

技术分享


还有一点需要说明一下，fork出的SystemServer进程在跳转到catch语句后，会执行SystemServer类的main()函数，而其他情况下，fork出的应用进程在跳转的catch语句后，则会执行ActivityThread类的main()函数。这个ActivityThread对于应用程序而言非常重要，但因为和本篇主题关系不大，我们就不在这里展开讲了。

3.2.4.3 SystemServer的main()函数

前文我们已经看到了，startSystemServer()创建的新进程在执行完applicationInit()之后，会抛出一个异常，并由新fork出的SystemServer子进程的catch语句接住，继而执行SystemServer类的main()函数。

那么SystemServer的main()函数又在做什么事情呢？其调用关系图如下：

 

技术分享


在Android4.4版本中，ServerThread已经不再继承于Thread了，它现在只是个辅助类，其命名还残留有旧代码的味道。在以前的Android版本中，ServerThread的确继承于Thread，而且在线程的run()成员函数里，做着类似addService、systemReady的工作。

 

因为本文主要是阐述zygote进程的，所以我们就不在这里继续细说system server进程啦，有兴趣的同学可以继续研究。我们还是回过头继续说zygote里的动作吧。

 

3.2.5监听zygote socket

3.2.5.1runSelectLoop()

ZygoteInit的main()函数在调用完startSystemServer()之后，会进一步走到runSelectLoop()。runSelectInit()的代码如下：
【frameworks/base/core/java/com/android/internal/os/ZygoteInit.java】

 

[java] view plain copy
 
  1. private static void runSelectLoop() throws MethodAndArgsCaller   
  2. {  
  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.   
  14.         if (loopCount <= 0) {  
  15.             gc();  
  16.             loopCount = GC_LOOP_COUNT;  
  17.         } else {  
  18.             loopCount--;  
  19.         }  
  20.   
  21.         try {  
  22.             fdArray = fds.toArray(fdArray);  
  23.             index = selectReadable(fdArray);  
  24.         } catch (IOException ex) {  
  25.             throw new RuntimeException("Error in select()", ex);  
  26.         }  
  27.   
  28.         if (index < 0) {  
  29.             throw new RuntimeException("Error in select()");  
  30.         } else if (index == 0) {  
  31.             ZygoteConnection newPeer = acceptCommandPeer();  
  32.             peers.add(newPeer);  
  33.             fds.add(newPeer.getFileDesciptor());  
  34.         } else {  
  35.             boolean done;  
  36.             done = peers.get(index).runOnce();  
  37.             if (done) {  
  38.                 peers.remove(index);  
  39.                 fds.remove(index);  
  40.             }  
  41.         }  
  42.     }  
  43. }  

 

在一个while循环中，不断调用selectReadable()。该函数是个native函数，对应C++层的com_android_internal_os_ZygoteInit_selectReadable()。

【frameworks/base/core/jni/com_android_internal_os_ZygoteInit.cpp】

 

[cpp] view plain copy
 
  1. static jint com_android_internal_os_ZygoteInit_selectReadable (JNIEnv *env, jobject clazz,   
  2.                                                                          jobjectArray fds)  
  3. {  
  4.     . . . . . .  
  5.     int err;  
  6.     do {  
  7.         err = select (nfds, &fdset, NULL, NULL, NULL);  
  8.     } while (err < 0 && errno == EINTR);  
  9.     . . . . . .  
  10.     for (jsize i = 0; i < length; i++) {  
  11.         jobject fdObj = env->GetObjectArrayElement(fds, i);  
  12.         . . . . . .  
  13.         int fd = jniGetFDFromFileDescriptor(env, fdObj);  
  14.         . . . . . .  
  15.         if (FD_ISSET(fd, &fdset)) {  
  16.             return (jint)i;  
  17.         }  
  18.     }  
  19.     return -1;  
  20. }  

 

可以看到，主要就是调用select()而已。在Linux的socket编程中，select()负责监视若干文件描述符的变化情况，我们常见的变化情况有：读、写、异常等等。在zygote中，

err = select (nfds, &fdset, NULL, NULL, NULL);一句的最后三个参数都为NULL，表示该select()操作只打算监视文件描述符的“读变化”，而且如果没有可读的文件，select()就维持阻塞状态。

在被监视的文件描述符数组（fds）中，第一个文件描述符对应着“zygote接收其他进程连接申请的那个socket（及sServerSocket）”，一旦它发生了变化，我们就尝试建立一个ZygoteConnection。

 

[java] view plain copy
 
  1. // (index == 0)的情况  
  2.             ZygoteConnection newPeer = acceptCommandPeer();  
  3.             peers.add(newPeer);  
  4.             fds.add(newPeer.getFileDesciptor());  

 

看到了吗，新创建的ZygoteConnection会被再次写入文件描述符数组（fds）。

如果select动作发现文件描述符数组（fds）的其他文件描述符有东西可读了，说明有其他进程通过某个已建立好的ZygoteConnection发来了命令，此时我们需要调用runOnce()。

 

[java] view plain copy
 
  1. // (index > 0)的情况  
  2.             boolean done;  
  3.             done = peers.get(index).runOnce();  
  4.             if (done) {  
  5.                 peers.remove(index);  
  6.                 fds.remove(index);  
  7.             }  

 

建立ZygoteConnection的acceptCommandPeer()的代码如下：
[java] view plain copy
 
  1. private static ZygoteConnection acceptCommandPeer() {  
  2.     try {  
  3.         return new ZygoteConnection(sServerSocket.accept());  
  4.     } catch (IOException ex) {  
  5.         throw new RuntimeException(  
  6.                 "IOException during accept()", ex);  
  7.     }  
  8. }  
 
3.2.5.1.1ZygoteConnection的runOnce()

ZygoteConnection的runOnce()代码截选如下：

 

[java] view plain copy
 
  1. boolean runOnce() throws ZygoteInit.MethodAndArgsCaller {  
  2.   
  3.     String args[];  
  4.     Arguments parsedArgs = null;  
  5.     FileDescriptor[] descriptors;  
  6.   
  7.     . . . . . .  
  8.         args = readArgumentList();  
  9.         descriptors = mSocket.getAncillaryFileDescriptors();  
  10.     . . . . . .   
  11.     int pid = -1;  
  12.     FileDescriptor childPipeFd = null;  
  13.     FileDescriptor serverPipeFd = null;  
  14.   
  15.     try {  
  16.         parsedArgs = new Arguments(args);  
  17.         . . . . . .  
  18.         pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,  
  19.                 parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal,   
  20.                 parsedArgs.seInfo, parsedArgs.niceName);  
  21.     }   
  22.     . . . . . .  
  23.         if (pid == 0) {  
  24.             // in child  
  25.             IoUtils.closeQuietly(serverPipeFd);  
  26.             serverPipeFd = null;  
  27.             handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);  
  28.             return true;  
  29.         } else {  
  30.             // in parent...pid of < 0 means failure  
  31.             IoUtils.closeQuietly(childPipeFd);  
  32.             childPipeFd = null;  
  33.             return handleParentProc(pid, descriptors, serverPipeFd, parsedArgs);  
  34.         }  
  35.     . . . . . .  
  36. }    

 

 
3.2.5.1.2readArgumentList()

runOnce()中从socket中读取参数数据的动作是由readArgumentList()完成的，该函数的代码如下：

 

[java] view plain copy
 
  1. private String[] readArgumentList()  
  2.         throws IOException   
  3. {  
  4.     int argc;  
  5.     . . . . . .  
  6.         String s = mSocketReader.readLine();  
  7.     . . . . . .  
  8.         argc = Integer.parseInt(s);  
  9.     . . . . . .  
  10.     String[] result = new String[argc];  
  11.     for (int i = 0; i < argc; i++) {  
  12.         result[i] = mSocketReader.readLine();  
  13.         if (result[i] == null) {  
  14.             // We got an unexpected EOF.  
  15.             throw new IOException("truncated request");  
  16.         }  
  17.     }  
  18.     return result;  
  19. }  

 

可是是谁在向这个socket写入参数的呢？当然是AMS啦。

我们知道，当AMS需要启动一个新进程时，会调用类似下面的句子：

 

[java] view plain copy
 
  1. Process.ProcessStartResult startResult = Process.start("android.app.ActivityThread",  
  2.                     app.processName, uid, uid, gids, debugFlags, mountExternal,  
  3.                     app.info.targetSdkVersion, app.info.seinfo, null);  

 

包括ActivityThread类名等重要信息的参数，最终就会通过socket传递给zygote。
3.2.5.1.3handleChildProc()

runOnce()在读完参数之后，会进一步调用到handleChildProc()。正如前文所说，该函数会间接抛出特殊的MethodAndArgsCaller异常，只不过此时抛出的异常携带的类名为ActivityThread。

 

[java] view plain copy
 
  1. private void handleChildProc(Arguments parsedArgs, FileDescriptor[] descriptors,   
  2.                              FileDescriptor pipeFd, PrintStream newStderr)  
  3.                              throws ZygoteInit.MethodAndArgsCaller   
  4. {  
  5.     closeSocket();  
  6.     ZygoteInit.closeServerSocket();  
  7.     . . . . . .  
  8.     if (parsedArgs.niceName != null) {  
  9.         Process.setArgV0(parsedArgs.niceName);  
  10.     }  
  11.   
  12.     if (parsedArgs.runtimeInit) {  
  13.         if (parsedArgs.invokeWith != null) {  
  14.             WrapperInit.execApplication(parsedArgs.invokeWith,  
  15.                     parsedArgs.niceName, parsedArgs.targetSdkVersion,  
  16.                     pipeFd, parsedArgs.remainingArgs);  
  17.         } else {  
  18.             RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion,  
  19.                     parsedArgs.remainingArgs);  
  20.         }  
  21.     } else {  
  22.         String className;  
  23.         . . . . . .  
  24.             className = parsedArgs.remainingArgs[0];  
  25.         . . . . . .  
  26.         String[] mainArgs = new String[parsedArgs.remainingArgs.length - 1];  
  27.         System.arraycopy(parsedArgs.remainingArgs, 1,  
  28.                 mainArgs, 0, mainArgs.length);  
  29.   
  30.         if (parsedArgs.invokeWith != null) {  
  31.             WrapperInit.execStandalone(parsedArgs.invokeWith,  
  32.                     parsedArgs.classpath, className, mainArgs);  
  33.         } else {  
  34.             ClassLoader cloader;  
  35.             if (parsedArgs.classpath != null) {  
  36.                 cloader = new PathClassLoader(parsedArgs.classpath,  
  37.                         ClassLoader.getSystemClassLoader());  
  38.             } else {  
  39.                 cloader = ClassLoader.getSystemClassLoader();  
  40.             }  
  41.   
  42.             try {  
  43.                 ZygoteInit.invokeStaticMain(cloader, className, mainArgs);  
  44.             } catch (RuntimeException ex) {  
  45.                 logAndPrintError(newStderr, "Error starting.", ex);  
  46.             }  
  47.         }  
  48.     }  
  49. }  

 

 

4小结

至此，zygote进程就阐述完毕了。作为一个最原始的“受精卵”，它必须在合适的时机进行必要的细胞分裂。分裂动作也没什么大的花样，不过就是fork()新进程而已。如果fork()出的新进程是system server，那么其最终执行的就是SystemServer类的main()函数，而如果fork()出的新进程是普通的用户进程的话，那么其最终执行的就是ActivityThread类的main()函数。有关ActivityThread的细节，我们有时间再深入探讨，这里就不细说了。

本篇文章和我的上一篇文章《Android4.4的init进程》可以算是姊妹篇啦。读完这两篇文章，我相信大家对Android的启动流程能有一些大面上的认识了。

转自http://blog.csdn.net/codefly/article/details/48413829

Android4.4的zygote进程（下）

标签：

原文地址：http://www.cnblogs.com/lzlltmf/p/5906799.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！