AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Zygote进程【2】——Zygote的分裂

2017-11-14 1229
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

在Zygote的诞生一文中init进程是如何一步步创建Zygote进程的，也了解了Zygote的进程的作用。Zygote进程的诞生对于整个Java世界可以说有着”开天辟地“的作用，它创建了Java虚拟机，并且繁殖了Java世界的核心服务system_server进程，在完成Java世界的初创工作以后，Zygote并没有死去，它只是暂时的沉睡（socket事件堵塞）在那里，一旦有需要（有客户端请求的到来），它便马上起来工作。本文接下来就将分析一下Zygote是如何监听和处理socket事件的。

首先让我们一起来回忆一下Zygote的main方法：

@frameworks/base/core/java/com/Android/internal/os/ZygoteInit.java

[java]  view plain  copy print?在CODE上查看代码片派生到我的代码片
  1.     public static void main(String argv[]) {  
  2.         try {  
  3.   
  4.             registerZygoteSocket();//注册zygote用的socket  
  5.   
  6.             ......  
  7.   
  8.             runSelectLoop();//变成守护进程，接收socket信息进行处理  
  9.   
  10.             closeServerSocket();  
  11.         } catch (MethodAndArgsCaller caller) {  
  12.             caller.run();  
  13.         } catch (RuntimeException ex) {  
  14.             Log.e(TAG, "Zygote died with exception", ex);  
  15.             closeServerSocket();  
  16.             throw ex;  
  17.         }  
  18.     }  

main（）方法首先在registerZygoteSocket中注册了Zygote的 服务端Socket对象，然后在完成一系列初创工作后调用runSelectLoop进入到死循环中，等待客户端事件的到来。到了这里我们不禁会问，Zygote进程作为服务端，那客户端是谁呢？Zygote接收到客户端连接以后又是如何处理的呢？下面我们就带着这两个问题一起来分析。


客户端请求

@/frameworks/base/services/java/com/android/server/am/ActivityManagerService.java

[java]  view plain  copy print?在CODE上查看代码片派生到我的代码片
  1. private final void startProcessLocked(ProcessRecord app,  
  2.         String hostingType, String hostingNameStr) {  
  3.     ......  
  4.     try {  
  5.         ......  
  6.         // Start the process.  It will either succeed and return a result containing  
  7.         // the PID of the new process, or else throw a RuntimeException.  
  8.         Process.ProcessStartResult startResult = Process.start("android.app.ActivityThread",  
  9.                 app.processName, uid, uid, gids, debugFlags, mountExternal,  
  10.                 app.info.targetSdkVersion, app.info.seinfo, null);  
  11.         .......  
  12. }  

@/frameworks/base/core/java/android/os/Process.java

[java]  view plain  copy print?在CODE上查看代码片派生到我的代码片
  1. /** 
  2.   * Start a new process. 
  3.   *  
  4.   * <p>If processes are enabled, a new process is created and the 
  5.   * static main() function of a <var>processClass</var> is executed there. 
  6.   * The process will continue running after this function returns. 
  7.   *  
  8.   * <p>If processes are not enabled, a new thread in the caller's 
  9.   * process is created and main() of <var>processClass</var> called there. 
  10.   *  
  11.   * <p>The niceName parameter, if not an empty string, is a custom name to 
  12.   * give to the process instead of using processClass.  This allows you to 
  13.   * make easily identifyable processes even if you are using the same base 
  14.   * <var>processClass</var> to start them. 
  15.   *  
  16.   * @param processClass The class to use as the process's main entry 
  17.   *                     point. 
  18.   * @param niceName A more readable name to use for the process. 
  19.   * @param uid The user-id under which the process will run. 
  20.   * @param gid The group-id under which the process will run. 
  21.   * @param gids Additional group-ids associated with the process. 
  22.   * @param debugFlags Additional flags. 
  23.   * @param targetSdkVersion The target SDK version for the app. 
  24.   * @param seInfo null-ok SE Android information for the new process. 
  25.   * @param zygoteArgs Additional arguments to supply to the zygote process. 
  26.   *  
  27.   * @return An object that describes the result of the attempt to start the process. 
  28.   * @throws RuntimeException on fatal start failure 
  29.   *  
  30.   * {@hide} 
  31.   */  
  32.  public static final ProcessStartResult start(final String processClass,  
  33.                                final String niceName,  
  34.                                int uid, int gid, int[] gids,  
  35.                                int debugFlags, int mountExternal,  
  36.                                int targetSdkVersion,  
  37.                                String seInfo,  
  38.                                String[] zygoteArgs) {  
  39.      try {  
  40.          return startViaZygote(processClass, niceName, uid, gid, gids,  
  41.                  debugFlags, mountExternal, targetSdkVersion, seInfo, zygoteArgs);  
  42.      } catch (ZygoteStartFailedEx ex) {  
  43.          Log.e(LOG_TAG,  
  44.                  "Starting VM process through Zygote failed");  
  45.          throw new RuntimeException(  
  46.                  "Starting VM process through Zygote failed", ex);  
  47.      }  
  48.  }  

startViaZygote()方法的实现如下：

[java]  view plain  copy print?在CODE上查看代码片派生到我的代码片
  1. /** 
  2.  * Starts a new process via the zygote mechanism. 
  3.  * 
  4.  * @param processClass Class name whose static main() to run 
  5.  * @param niceName 'nice' process name to appear in ps 
  6.  * @param uid a POSIX uid that the new process should setuid() to 
  7.  * @param gid a POSIX gid that the new process shuold setgid() to 
  8.  * @param gids null-ok; a list of supplementary group IDs that the 
  9.  * new process should setgroup() to. 
  10.  * @param debugFlags Additional flags. 
  11.  * @param targetSdkVersion The target SDK version for the app. 
  12.  * @param seInfo null-ok SE Android information for the new process. 
  13.  * @param extraArgs Additional arguments to supply to the zygote process. 
  14.  * @return An object that describes the result of the attempt to start the process. 
  15.  * @throws ZygoteStartFailedEx if process start failed for any reason 
  16.  */  
  17. private static ProcessStartResult startViaZygote(final String processClass,  
  18.                               final String niceName,  
  19.                               final int uid, final int gid,  
  20.                               final int[] gids,  
  21.                               int debugFlags, int mountExternal,  
  22.                               int targetSdkVersion,  
  23.                               String seInfo,  
  24.                               String[] extraArgs)  
  25.                               throws ZygoteStartFailedEx {  
  26.     synchronized(Process.class) {  
  27.         ArrayList<String> argsForZygote = new ArrayList<String>();  
  28.   
  29.         // --runtime-init, --setuid=, --setgid=,  
  30.         // and --setgroups= must go first  
  31.         argsForZygote.add("--runtime-init");  
  32.         argsForZygote.add("--setuid=" + uid);  
  33.         argsForZygote.add("--setgid=" + gid);  
  34.         if ((debugFlags & Zygote.DEBUG_ENABLE_JNI_LOGGING) != 0) {  
  35.             argsForZygote.add("--enable-jni-logging");  
  36.         }  
  37.         if ((debugFlags & Zygote.DEBUG_ENABLE_SAFEMODE) != 0) {  
  38.             argsForZygote.add("--enable-safemode");  
  39.         }  
  40.         if ((debugFlags & Zygote.DEBUG_ENABLE_DEBUGGER) != 0) {  
  41.             argsForZygote.add("--enable-debugger");  
  42.         }  
  43.         if ((debugFlags & Zygote.DEBUG_ENABLE_CHECKJNI) != 0) {  
  44.             argsForZygote.add("--enable-checkjni");  
  45.         }  
  46.         if ((debugFlags & Zygote.DEBUG_ENABLE_ASSERT) != 0) {  
  47.             argsForZygote.add("--enable-assert");  
  48.         }  
  49.         if (mountExternal == Zygote.MOUNT_EXTERNAL_MULTIUSER) {  
  50.             argsForZygote.add("--mount-external-multiuser");  
  51.         } else if (mountExternal == Zygote.MOUNT_EXTERNAL_MULTIUSER_ALL) {  
  52.             argsForZygote.add("--mount-external-multiuser-all");  
  53.         }  
  54.         argsForZygote.add("--target-sdk-version=" + targetSdkVersion);  
  55.   
  56.         //TODO optionally enable debuger  
  57.         //argsForZygote.add("--enable-debugger");  
  58.   
  59.         // --setgroups is a comma-separated list  
  60.         if (gids != null && gids.length > 0) {  
  61.             StringBuilder sb = new StringBuilder();  
  62.             sb.append("--setgroups=");  
  63.   
  64.             int sz = gids.length;  
  65.             for (int i = 0; i < sz; i++) {  
  66.                 if (i != 0) {  
  67.                     sb.append(',');  
  68.                 }  
  69.                 sb.append(gids[i]);  
  70.             }  
  71.   
  72.             argsForZygote.add(sb.toString());  
  73.         }  
  74.   
  75.         if (niceName != null) {  
  76.             argsForZygote.add("--nice-name=" + niceName);  
  77.         }  
  78.   
  79.         if (seInfo != null) {  
  80.             argsForZygote.add("--seinfo=" + seInfo);  
  81.         }  
  82.   
  83.         argsForZygote.add(processClass);  
  84.   
  85.         if (extraArgs != null) {  
  86.             for (String arg : extraArgs) {  
  87.                 argsForZygote.add(arg);  
  88.             }  
  89.         }  
  90.   
  91.         return zygoteSendArgsAndGetResult(argsForZygote);  
  92.     }  
  93. }  

startViaZygote的绝大部分代码都在处理传递到Zygote中的参数，与Zygote通信通过zygoteSendArgsAndGetResult()方法完成：

[java]  view plain  copy print?在CODE上查看代码片派生到我的代码片
  1. /** 
  2.  * Sends an argument list to the zygote process, which starts a new child 
  3.  * and returns the child's pid. Please note: the present implementation 
  4.  * replaces newlines in the argument list with spaces. 
  5.  * @param args argument list 
  6.  * @return An object that describes the result of the attempt to start the process. 
  7.  * @throws ZygoteStartFailedEx if process start failed for any reason 
  8.  */  
  9. private static ProcessStartResult zygoteSendArgsAndGetResult(ArrayList<String> args)  
  10.         throws ZygoteStartFailedEx {  
  11.     openZygoteSocketIfNeeded();//确保和Zygote通信的socket已被打开  
  12.   
  13.     try {  
  14.         /** 
  15.          * See com.android.internal.os.ZygoteInit.readArgumentList() 
  16.          * Presently the wire format to the zygote process is: 
  17.          * a) a count of arguments (argc, in essence) 
  18.          * b) a number of newline-separated argument strings equal to count 
  19.          * 
  20.          * After the zygote process reads these it will write the pid of 
  21.          * the child or -1 on failure, followed by boolean to 
  22.          * indicate whether a wrapper process was used. 
  23.          */  
  24.   
  25.         sZygoteWriter.write(Integer.toString(args.size()));  
  26.         sZygoteWriter.newLine();  
  27.   
  28.         int sz = args.size();  
  29.         for (int i = 0; i < sz; i++) {//发送请求参数到Zygote  
  30.             String arg = args.get(i);  
  31.             if (arg.indexOf('\n') >= 0) {  
  32.                 throw new ZygoteStartFailedEx(  
  33.                         "embedded newlines not allowed");  
  34.             }  
  35.             sZygoteWriter.write(arg);  
  36.             sZygoteWriter.newLine();  
  37.         }  
  38.   
  39.         sZygoteWriter.flush();  
  40.   
  41.         // Should there be a timeout on this?  
  42.         ProcessStartResult result = new ProcessStartResult();  
  43.         result.pid = sZygoteInputStream.readInt();//Zygote处理完成会返回子进程的pid（即要创建的进程）  
  44.         if (result.pid < 0) {  
  45.             throw new ZygoteStartFailedEx("fork() failed");  
  46.         }  
  47.         result.usingWrapper = sZygoteInputStream.readBoolean();  
  48.         return result;  
  49.     } catch (IOException ex) {  
  50.         try {  
  51.             if (sZygoteSocket != null) {  
  52.                 sZygoteSocket.close();  
  53.             }  
  54.         } catch (IOException ex2) {  
  55.             // we're going to fail anyway  
  56.             Log.e(LOG_TAG,"I/O exception on routine close", ex2);  
  57.         }  
  58.   
  59.         sZygoteSocket = null;  
  60.   
  61.         throw new ZygoteStartFailedEx(ex);  
  62.     }  
  63. }  

到这里位置，客户端请求Zygote创建进程的请求就发送出去了，Zygote会返回进行的pid给客户端（ActivityMangerService）。由于ActivityMangerService在SystemServer进程中，所以这里即SystemServer进程通过socket向Zygote发送了信息。 

接下来，我们看一下看一下Zygote是如何处理客户端请求的。


处理客户端请求

[java]  view plain  copy print?在CODE上查看代码片派生到我的代码片
  1.     /** 
  2.      * Runs the zygote process's select loop. Accepts new connections as 
  3.      * they happen, and reads commands from connections one spawn-request's 
  4.      * worth at a time. 
  5.      * 
  6.      * @throws MethodAndArgsCaller in a child process when a main() should 
  7.      * be executed. 
  8.      */  
  9.     private static void runSelectLoop() throws MethodAndArgsCaller {  
  10.     <span style="white-space:pre">  </span>......  
  11.     <span style="white-space:pre">  </span>  
  12.         while (true) {//死循环  
  13.             ......  
  14.               
  15.             if (index < 0) {  
  16.                 throw new RuntimeException("Error in select()");  
  17.             } else if (index == 0) {//index==0表示selcet接收到的是Zygote的socket的事件  
  18.                 ZygoteConnection newPeer = acceptCommandPeer();  
  19.                 peers.add(newPeer);  
  20.                 fds.add(newPeer.getFileDesciptor());  
  21.             } else {//调用ZygoteConnection对象的runOnce方法，ZygoteConnection是在index == 0时被添加到peers的  
  22.                 boolean done;  
  23.                 done = peers.get(index).runOnce();  
  24.   
  25.   
  26.                 if (done) {  
  27.                     peers.remove(index);  
  28.                     fds.remove(index);  
  29.                 }  
  30.             }  
  31.         }  
  32.     }  

每当有请求过来时，Zygote都会调用ZygoteConnection的runOnce()方法处理：

@/frameworks/base/core/java/com/android/internal/os/ZygoteConnection.java

[java]  view plain  copy print?在CODE上查看代码片派生到我的代码片
  1. /** 
  2.  * Reads one start command from the command socket. If successful, 
  3.  * a child is forked and a {@link ZygoteInit.MethodAndArgsCaller} 
  4.  * exception is thrown in that child while in the parent process, 
  5.  * the method returns normally. On failure, the child is not 
  6.  * spawned and messages are printed to the log and stderr. Returns 
  7.  * a boolean status value indicating whether an end-of-file on the command 
  8.  * socket has been encountered. 
  9.  * 
  10.  * @return false if command socket should continue to be read from, or 
  11.  * true if an end-of-file has been encountered. 
  12.  * @throws ZygoteInit.MethodAndArgsCaller trampoline to invoke main() 
  13.  * method in child process 
  14.  */  
  15. boolean runOnce() throws ZygoteInit.MethodAndArgsCaller {  
  16.   
  17.     String args[];  
  18.     Arguments parsedArgs = null;  
  19.     FileDescriptor[] descriptors;  
  20.   
  21.     try {  
  22.         args = readArgumentList();//读取客户端发送过来的参数  
  23.         descriptors = mSocket.getAncillaryFileDescriptors();  
  24.     } catch (IOException ex) {  
  25.         Log.w(TAG, "IOException on command socket " + ex.getMessage());  
  26.         closeSocket();  
  27.         return true;  
  28.     }  
  29.   
  30.     if (args == null) {  
  31.         // EOF reached.  
  32.         closeSocket();  
  33.         return true;  
  34.     }  
  35.   
  36.     /** the stderr of the most recent request, if avail */  
  37.     PrintStream newStderr = null;  
  38.   
  39.     if (descriptors != null && descriptors.length >= 3) {  
  40.         newStderr = new PrintStream(  
  41.                 new FileOutputStream(descriptors[2]));  
  42.     }  
  43.   
  44.     int pid = -1;  
  45.     FileDescriptor childPipeFd = null;  
  46.     FileDescriptor serverPipeFd = null;  
  47.   
  48.     try {  
  49.         parsedArgs = new Arguments(args);  
  50.   
  51.         applyUidSecurityPolicy(parsedArgs, peer, peerSecurityContext);  
  52.         applyRlimitSecurityPolicy(parsedArgs, peer, peerSecurityContext);  
  53.         applyCapabilitiesSecurityPolicy(parsedArgs, peer, peerSecurityContext);  
  54.         applyInvokeWithSecurityPolicy(parsedArgs, peer, peerSecurityContext);  
  55.         applyseInfoSecurityPolicy(parsedArgs, peer, peerSecurityContext);  
  56.   
  57.         applyDebuggerSystemProperty(parsedArgs);  
  58.         applyInvokeWithSystemProperty(parsedArgs);  
  59.   
  60.         int[][] rlimits = null;  
  61.   
  62.         if (parsedArgs.rlimits != null) {  
  63.             rlimits = parsedArgs.rlimits.toArray(intArray2d);  
  64.         }  
  65.   
  66.         if (parsedArgs.runtimeInit && parsedArgs.invokeWith != null) {  
  67.             FileDescriptor[] pipeFds = Libcore.os.pipe();  
  68.             childPipeFd = pipeFds[1];  
  69.             serverPipeFd = pipeFds[0];  
  70.             ZygoteInit.setCloseOnExec(serverPipeFd, true);  
  71.         }  
  72.   
  73.         //fork一个新进程  
  74.         pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,  
  75.                 parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,  
  76.                 parsedArgs.niceName);  
  77.     } catch (IOException ex) {  
  78.         logAndPrintError(newStderr, "Exception creating pipe", ex);  
  79.     } catch (ErrnoException ex) {  
  80.         logAndPrintError(newStderr, "Exception creating pipe", ex);  
  81.     } catch (IllegalArgumentException ex) {  
  82.         logAndPrintError(newStderr, "Invalid zygote arguments", ex);  
  83.     } catch (ZygoteSecurityException ex) {  
  84.         logAndPrintError(newStderr,  
  85.                 "Zygote security policy prevents request: ", ex);  
  86.     }  
  87.   
  88.     try {  
  89.         if (pid == 0) {//子进程  
  90.             // in child  
  91.             IoUtils.closeQuietly(serverPipeFd);  
  92.             serverPipeFd = null;  
  93.             handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);  
  94.   
  95.             // should never get here, the child is expected to either  
  96.             // throw ZygoteInit.MethodAndArgsCaller or exec().  
  97.             return true;  
  98.         } else {//父进程  
  99.             // in parent...pid of < 0 means failure  
  100.             IoUtils.closeQuietly(childPipeFd);  
  101.             childPipeFd = null;  
  102.             return handleParentProc(pid, descriptors, serverPipeFd, parsedArgs);  
  103.         }  
  104.     } finally {  
  105.         IoUtils.closeQuietly(childPipeFd);  
  106.         IoUtils.closeQuietly(serverPipeFd);  
  107.     }  
  108. }  

Zygote在处理客户端请求时会fork一个新的进程，接下来首先看一下handleChildProc（）方法：

[java]  view plain  copy print?在CODE上查看代码片派生到我的代码片
  1. /** 
  2.  * Handles post-fork setup of child proc, closing sockets as appropriate, 
  3.  * reopen stdio as appropriate, and ultimately throwing MethodAndArgsCaller 
  4.  * if successful or returning if failed. 
  5.  * 
  6.  * @param parsedArgs non-null; zygote args 
  7.  * @param descriptors null-ok; new file descriptors for stdio if available. 
  8.  * @param pipeFd null-ok; pipe for communication back to Zygote. 
  9.  * @param newStderr null-ok; stream to use for stderr until stdio 
  10.  * is reopened. 
  11.  * 
  12.  * @throws ZygoteInit.MethodAndArgsCaller on success to 
  13.  * trampoline to code that invokes static main. 
  14.  */  
  15. private void handleChildProc(Arguments parsedArgs,  
  16.         FileDescriptor[] descriptors, FileDescriptor pipeFd, PrintStream newStderr)  
  17.         throws ZygoteInit.MethodAndArgsCaller {  
  18.   
  19.     closeSocket();//关闭子进程中，从Zygote fork过来的服务端socket  
  20.     ZygoteInit.closeServerSocket();  
  21.   
  22.     .....  
  23.       
  24.     if (parsedArgs.niceName != null) {  
  25.         Process.setArgV0(parsedArgs.niceName);  
  26.     }  
  27.   
  28.     if (parsedArgs.runtimeInit) {//从startViaZygote可知传入了--runtime-init参数，所以这里为true  
  29.         if (parsedArgs.invokeWith != null) {//没有传入--invoke-with，所以这里走的是else的逻辑  
  30.             WrapperInit.execApplication(parsedArgs.invokeWith,  
  31.                     parsedArgs.niceName, parsedArgs.targetSdkVersion,  
  32.                     pipeFd, parsedArgs.remainingArgs);  
  33.         } else {  
  34.             RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion,  
  35.                     parsedArgs.remainingArgs);  
  36.         }  
  37.     } else {  
  38.         ......  
  39.     }  
  40. }  

zygoteInit()方法的实现在RuntimeInit类中：

@/frameworks/base/core/java/com/android/internal/os/RuntimeInit.java

[java]  view plain  copy print?在CODE上查看代码片派生到我的代码片
  1.     /** 
  2.      * The main function called when started through the zygote process. This 
  3.      * could be unified with main(), if the native code in nativeFinishInit() 
  4.      * were rationalized with Zygote startup.<p> 
  5.      * 
  6.      * Current recognized args: 
  7.      * <ul> 
  8.      *   <li> <code> [--] &lt;start class name&gt;  &lt;args&gt; 
  9.      * </ul> 
  10.      * 
  11.      * @param targetSdkVersion target SDK version 
  12.      * @param argv arg strings 
  13.      */  
  14.     public static final void zygoteInit(int targetSdkVersion, String[] argv)  
  15.             throws ZygoteInit.MethodAndArgsCaller {  
  16.         if (DEBUG) Slog.d(TAG, "RuntimeInit: Starting application from zygote");  
  17.   
  18.   
  19.         redirectLogStreams();//将System.out 和 System.err 输出重定向到Android 的Log系统  
  20.         /* 
  21.          * 初始化了一些系统属性，其中最重要的一点就是设置了一个未捕捉异常的handler， 
  22.          * 当代码有任何未知异常，就会执行它， 
  23.          * 调试过Android代码的同学经常看到的"*** FATAL EXCEPTION IN SYSTEM PROCESS" 打印就出自这里 
  24.          */  
  25.         commonInit();  
  26.         /* 
  27.          * 最终会调用app_main的onZygoteInit函数 
  28.          * 这里的作用是在新进程中引入Binder，也就说通过nativeZygoteInit以后，新的进程就可以使用Binder进程通信了 
  29.          */  
  30.         nativeZygoteInit();  
  31.   
  32.   
  33.         applicationInit(targetSdkVersion, argv);//应用初始化  
  34.     }  

接下来继续分析applicationInit（），走完进程启动的整个过程，然后再回头分析一下commonInit和nativeZygoteInit的实现。applicationInit的实现如下：

[java]  view plain  copy print?在CODE上查看代码片派生到我的代码片
  1. private static void applicationInit(int targetSdkVersion, String[] argv)  
  2.         throws ZygoteInit.MethodAndArgsCaller {  
  3.     // If the application calls System.exit(), terminate the process  
  4.     // immediately without running any shutdown hooks.  It is not possible to  
  5.     // shutdown an Android application gracefully.  Among other things, the  
  6.     // Android runtime shutdown hooks close the Binder driver, which can cause  
  7.     // leftover running threads to crash before the process actually exits.  
  8.     nativeSetExitWithoutCleanup(true);  
  9.   
  10.     // We want to be fairly aggressive about heap utilization, to avoid  
  11.     // holding on to a lot of memory that isn't needed.  
  12.     VMRuntime.getRuntime().setTargetHeapUtilization(0.75f);  
  13.     VMRuntime.getRuntime().setTargetSdkVersion(targetSdkVersion);  
  14.   
  15.     final Arguments args;  
  16.     try {  
  17.         args = new Arguments(argv);  
  18.     } catch (IllegalArgumentException ex) {  
  19.         Slog.e(TAG, ex.getMessage());  
  20.         // let the process exit  
  21.         return;  
  22.     }  
  23.   
  24.     // Remaining arguments are passed to the start class's static main  
  25.     invokeStaticMain(args.startClass, args.startArgs);  
  26. }  

在applicationInit()的最后，会通过调用invokeStaticMain来调用args.startClass这个类的main（）方法。在前面介绍socket的客户端代码时，在startProcessLocked()中传入的这个类为在CODE上查看代码片派生到我的代码片

  1. /** 
  2.   * Invokes a static "main(argv[]) method on class "className". 
  3.   * Converts various failing exceptions into RuntimeExceptions, with 
  4.   * the assumption that they will then cause the VM instance to exit. 
  5.   * 
  6.   * @param className Fully-qualified class name 
  7.   * @param argv Argument vector for main() 
  8.   */  
  9.  private static void invokeStaticMain(String className, String[] argv)  
  10.          throws ZygoteInit.MethodAndArgsCaller {  
  11.      Class<?> cl;  
  12.   
  13.      try {  
  14.          cl = Class.forName(className);  
  15.      } catch (ClassNotFoundException ex) {  
  16.          throw new RuntimeException(  
  17.                  "Missing class when invoking static main " + className,  
  18.                  ex);  
  19.      }  
  20.   
  21.      Method m;  
  22.      try {  
  23.          m = cl.getMethod("main", new Class[] { String[].class });  
  24.      } catch (NoSuchMethodException ex) {  
  25.          throw new RuntimeException(  
  26.                  "Missing static main on " + className, ex);  
  27.      } catch (SecurityException ex) {  
  28.          throw new RuntimeException(  
  29.                  "Problem getting static main on " + className, ex);  
  30.      }  
  31.   
  32.      int modifiers = m.getModifiers();  
  33.      if (! (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))) {  
  34.          throw new RuntimeException(  
  35.                  "Main method is not public and static on " + className);  
  36.      }  
  37.   
  38.      /* 
  39.       * This throw gets caught in ZygoteInit.main(), which responds 
  40.       * by invoking the exception's run() method. This arrangement 
  41.       * clears up all the stack frames that were required in setting 
  42.       * up the process. 
  43.       */  
  44.      throw new ZygoteInit.MethodAndArgsCaller(m, argv);  
  45.  }  

这个方法本身功能就是调用ActivityThread类的main（），没什么可说的。不过需要注意一下的是这里的调用方式十分特别，并没有采取常规的反射调用，而是通过抛出异常的方式调用ActivityThread的main（）函数。这里抛出的ZygoteInit.MethodAndArgsCaller异常会在ZygoteInit.main()中被捕获处理。

[java]  view plain  copy print?在CODE上查看代码片派生到我的代码片
  1. public static void main(String argv[]) {  
  2.     try {  
  3.         ......  
  4.     } catch (MethodAndArgsCaller caller) {  
  5.         caller.run();  
  6.     } catch (RuntimeException ex) {  
  7.         ......  
  8.     }  
  9. }  

这里需要注意的是：捕获异常是在子进程（即新的进程，不是Zygote进程）中的动作。还记得前面介绍的runOnce()方法吗？我们在runOnce中创建了一个新的进程。如果读者还有不明白这里为什么是在子进程，可以自行学习Linux fork（）的原理。好了，继续..... 看一下MethodAndArgsCaller的代码：

@/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

[java]  view plain  copy print?在CODE上查看代码片派生到我的代码片
  1. /** 
  2.  * Helper exception class which holds a method and arguments and 
  3.  * can call them. This is used as part of a trampoline to get rid of 
  4.  * the initial process setup stack frames. 
  5.  */  
  6. public static class MethodAndArgsCaller extends Exception  
  7.         implements Runnable {  
  8.     /** method to call */  
  9.     private final Method mMethod;  
  10.   
  11.     /** argument array */  
  12.     private final String[] mArgs;  
  13.   
  14.     public MethodAndArgsCaller(Method method, String[] args) {  
  15.         mMethod = method;  
  16.         mArgs = args;  
  17.     }  
  18.   
  19.     public void run() {  
  20.         try {  
  21.             mMethod.invoke(null, new Object[] { mArgs });  
  22.         } catch (IllegalAccessException ex) {  
  23.             throw new RuntimeException(ex);  
  24.         } catch (InvocationTargetException ex) {  
  25.             Throwable cause = ex.getCause();  
  26.             if (cause instanceof RuntimeException) {  
  27.                 throw (RuntimeException) cause;  
  28.             } else if (cause instanceof Error) {  
  29.                 throw (Error) cause;  
  30.             }  
  31.             throw new RuntimeException(ex);  
  32.         }  
  33.     }  
  34. }  

可以看出最后还是会调用invoke方法通过反射的方式调用ActivityThread的main方法。

到了这里，相信大家都会有一个疑问：既然最后还是通过invoke来反射调用main方法，那绕这一大圈子到底在折腾什么？
有疑问的读者，有没有去思考过另外一个问题：我们为什么要通过Zygote去创建进程，而不是直接创建一个新的进程出来呢？这就要从Zygote创建进程的机制来解释。相信我们还记得在ZygoteInit的main函数中我们通过preload来预加载类和资源。所以这些被预加载的类和资源都存在于Zygote进程中。在通过Zygote创建进程时，我们是通过fork来创建的。 一个进程调用fork（）函数后，系统先给新的进程分配资源，例如存储数据和代码的空间。然后把原来的进程的所有值都复制到新的新进程中，只有少数值与原来的进程的值不同，相当于克隆了一个自己。所以，Zygote通过fork的方式创建新的应用进程的同时，会将对系统的（主要是framework中的）一些类和资源的引用同时复制给子进程，这样子进程中就可以使用这些资源了。这也是为什么所有的应用程序可以共享Framework中的类和资源的原因。

在明白了Zygote机制后，对应为什么这里会以抛出异常的方式调用ActivityThread（应用程序入口）的main（）方法，就变得容易理解了。在Java中，我们进行一些列的方法调用的时候，系统会为我们在内存中维护一个调用栈，栈底是发起调用的方法，栈顶是当前正在被调用的方法。在栈顶的方法调用完成后，会逐级返回调用它的方法，最后调用会回到最开始的方法中，然后调用栈就被销毁了。在Zygote处理客户端事件的时候，沿着各种方法一路调用下来，如果在调用ActivityThread中的main（）时，直接使用invoke，那么在invoke结束后，整个调用过程会递归返回，最后发起方得到调用结果，调用栈被销毁。然后每次的调用都会重复刚才的那个过程，这就造成了极大的浪费。采用异常的方式，可以保证调用栈不会被销毁，这样每次fork时就可以共享。

好了，到此为止Zygote的分裂过程就介绍完成了。





    本文转自 一点点征服   博客园博客，原文链接：http://www.cnblogs.com/ldq2016/p/6232174.html，如需转载请自行联系原作者


文章标签：
Java
Android开发
Linux
存储
关键词：
zygote进程
技术小胖子
目录
相关文章
xiaowang_lj
|
8月前
|
存储 Java Android开发
Zygote进程启动过程
Zygote进程启动过程
xiaowang_lj
58 1
孤街酒客0911
|
Java Android开发
Android Zygote进程(二)
学习笔记
孤街酒客0911
242 0
Android Zygote进程(二)
孤街酒客0911
|
缓存 监控 网络协议
Android Zygote进程(一)
学习笔记
孤街酒客0911
624 0
Android Zygote进程(一)
公众号：小余的自习室
|
Java 调度 Android开发
android体系课-系统启动流程-之zygote进程启动过程源码分析
笔者刚开始学习Android的时候也和大部分同学一样，只会使用一些应用层面的知识，对于一些比较常见的开源框架如<mark>RxJava</mark>，<mark>OkHttp</mark>，<mark>Retrofit</mark>，以及后来谷歌推出的<mark>协程</mark>等，都只在使用层面，对于他们<mark>内部原理</mark>，基本没有去了解觉得够用就可以了，又比如Activity，Service等四大组件的使用原理，系统开机过程，Launcher启动过程等知之甚少，知其然而不知其所以然，结果就是出现某些问题，不知道从哪里找原因，只能依赖万能的百度，但是百度看多了，你会发现自己
公众号：小余的自习室
312 0
余二五
|
Java Android开发
Android系统进程Zygote启动过程的源代码分析（3）
余二五
912 0
余二五
|
Java Android开发
Android系统进程Zygote启动过程的源代码分析（2）
余二五
1080 0
技术小胖子
|
Java Linux Android开发
Zygote进程【1】——Zygote的诞生
技术小胖子
1365 0
技术小胖子
|
Java Android开发
Zygote进程【3】——SystemServer的诞生
技术小胖子
1111 0
余二五
|
Linux Android开发 C++
Android系统进程Zygote启动过程的源代码分析（1）
余二五
1320 0
Linux学习的那些事儿
|
6月前
|
运维 关系型数据库 MySQL
掌握taskset：优化你的Linux进程，提升系统性能
在多核处理器成为现代计算标准的今天，运维人员和性能调优人员面临着如何有效利用这些处理能力的挑战。优化进程运行的位置不仅可以提高性能，还能更好地管理和分配系统资源。 其中，taskset命令是一个强大的工具，它允许管理员将进程绑定到特定的CPU核心，减少上下文切换的开销，从而提升整体效率。
Linux学习的那些事儿
425 9
掌握taskset：优化你的Linux进程，提升系统性能

热门文章

最新文章

  • 1
    Linux：进程间通信（共享内存详细讲解以及小项目使用和相关指令、消息队列、信号量）
  • 2
    2025年1月9日更新Windows操作系统个人使用-禁用掉一下一些不必要的服务-关闭占用资源的进程-禁用服务提升系统运行速度-让电脑不再卡顿-优雅草央千澈-长期更新
  • 3
    从零开始掌握进程间通信：管道、信号、消息队列、共享内存大揭秘
  • 4
    [JavaEE]———进程、进程的数据结构、进程的调度
  • 5
    如何区分进程、线程和协程？看这篇就够了！
  • 6
    硬核揭秘：线程与进程的底层原理，面试高分必备！
  • 7
    dllhost.exe进程占用CPU很高怎么解决?
  • 8
    深入理解操作系统之进程调度
  • 9
    嵌入式Linux系统编程 — 5.3 times、clock函数获取进程时间
  • 10
    【运维】如何在Ubuntu中设置一个内存守护进程来确保内存不会溢出
  • 1
    硬核揭秘：线程与进程的底层原理，面试高分必备！
    26
  • 2
    从零开始掌握进程间通信：管道、信号、消息队列、共享内存大揭秘
    66
  • 3
    如何区分进程、线程和协程？看这篇就够了！
    44
  • 4
    2025年1月9日更新Windows操作系统个人使用-禁用掉一下一些不必要的服务-关闭占用资源的进程-禁用服务提升系统运行速度-让电脑不再卡顿-优雅草央千澈-长期更新
    71
  • 5
    Linux：进程间通信（共享内存详细讲解以及小项目使用和相关指令、消息队列、信号量）
    79
  • 6
    [JavaEE]———进程、进程的数据结构、进程的调度
    43
  • 7
    驱动性能提升，如何加速基于龙蜥和企业平台的Arm系统开发与部署进程？
    67
  • 8
    嵌入式Linux系统编程 — 5.3 times、clock函数获取进程时间
    110
  • 9
    【运维】如何在Ubuntu中设置一个内存守护进程来确保内存不会溢出
    81
  • 10
    如何找出Java进程占用CPU高的元凶
    67

    • 相关电子书

    更多
  • 服务上云加速大家居产业C2M进程
  • 低代码开发师（初级）实战教程
  • 阿里巴巴DevOps 最佳实践手册

    • 相关实验场景

    更多
  • 观察进程的并发性
    • 下一篇
    阿里云oss简介和如何对接使用