Android应用程序进程启动过程的源代码分析(2)

    Step 5. ZygoteInit.runSelectLoopMode
        这个函数定义在frameworks/base/core/java/com/android/internal/os/ZygoteInit.java文件中:
  
  
  
  
  1. public class ZygoteInit {   
  2.     ......   
  3.    
  4.     /**  
  5.     * Runs the zygote process's select loop. Accepts new connections as  
  6.     * they happen, and reads commands from connections one spawn-request's  
  7.     * worth at a time.  
  8.     *  
  9.     * @throws MethodAndArgsCaller in a child process when a main() should  
  10.     * be executed.  
  11.     */   
  12.     private static void runSelectLoopMode() throws MethodAndArgsCaller {   
  13.         ArrayList<FileDescriptor> fds = new ArrayList();   
  14.         ArrayList<ZygoteConnection> peers = new ArrayList();   
  15.         FileDescriptor[] fdArray = new FileDescriptor[4];   
  16.    
  17.         fds.add(sServerSocket.getFileDescriptor());   
  18.         peers.add(null);   
  19.    
  20.         int loopCount = GC_LOOP_COUNT;   
  21.         while (true) {   
  22.             int index;   
  23.             /*  
  24.             * Call gc() before we block in select().  
  25.             * It's work that has to be done anyway, and it's better  
  26.             * to avoid making every child do it.  It will also  
  27.             * madvise() any free memory as a side-effect.  
  28.             *  
  29.             * Don't call it every time, because walking the entire  
  30.             * heap is a lot of overhead to free a few hundred bytes.  
  31.             */   
  32.             if (loopCount <= 0) {   
  33.                 gc();   
  34.                 loopCount = GC_LOOP_COUNT;   
  35.             } else {   
  36.                 loopCount--;   
  37.             }   
  38.    
  39.    
  40.             try {   
  41.                 fdArray = fds.toArray(fdArray);   
  42.                 index = selectReadable(fdArray);   
  43.             } catch (IOException ex) {   
  44.                 throw new RuntimeException("Error in select()", ex);   
  45.             }   
  46.    
  47.             if (index < 0) {   
  48.                 throw new RuntimeException("Error in select()");   
  49.             } else if (index == 0) {   
  50.                 ZygoteConnection newPeer = acceptCommandPeer();   
  51.                 peers.add(newPeer);   
  52.                 fds.add(newPeer.getFileDesciptor());   
  53.             } else {   
  54.                 boolean done;   
  55.                 done = peers.get(index).runOnce();   
  56.    
  57.                 if (done) {   
  58.                     peers.remove(index);   
  59.                     fds.remove(index);   
  60.                 }   
  61.             }   
  62.         }   
  63.     }   
  64.    
  65.     ......   
  66. }   
        当Step 4将数据通过Socket接口发送出去后,就会下面这个语句:
  
  
  
  
  1. done = peers.get(index).runOnce();   
        这里从peers.get(index)得到的是一个ZygoteConnection对象,表示一个Socket连接,因此,接下来就是调用ZygoteConnection.runOnce函数进一步处理了。
 
        Step 6. ZygoteConnection.runOnce
        这个函数定义在frameworks/base/core/java/com/android/internal/os/ZygoteConnection.java文件中:
  
  
  
  
  1. class ZygoteConnection {   
  2.     ......   
  3.    
  4.     boolean runOnce() throws ZygoteInit.MethodAndArgsCaller {   
  5.         String args[];   
  6.         Arguments parsedArgs = null;   
  7.         FileDescriptor[] descriptors;   
  8.    
  9.         try {   
  10.             args = readArgumentList();   
  11.             descriptors = mSocket.getAncillaryFileDescriptors();   
  12.         } catch (IOException ex) {   
  13.             ......   
  14.             return true;   
  15.         }   
  16.    
  17.         ......   
  18.    
  19.         /** the stderr of the most recent request, if avail */   
  20.         PrintStream newStderr = null;   
  21.    
  22.         if (descriptors != null && descriptors.length >= 3) {   
  23.             newStderr = new PrintStream(   
  24.                 new FileOutputStream(descriptors[2]));   
  25.         }   
  26.    
  27.         int pid;   
  28.            
  29.         try {   
  30.             parsedArgs = new Arguments(args);   
  31.    
  32.             applyUidSecurityPolicy(parsedArgs, peer);   
  33.             applyDebuggerSecurityPolicy(parsedArgs);   
  34.             applyRlimitSecurityPolicy(parsedArgs, peer);   
  35.             applyCapabilitiesSecurityPolicy(parsedArgs, peer);   
  36.    
  37.             int[][] rlimits = null;   
  38.    
  39.             if (parsedArgs.rlimits != null) {   
  40.                 rlimits = parsedArgs.rlimits.toArray(intArray2d);   
  41.             }   
  42.    
  43.             pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid,   
  44.                 parsedArgs.gids, parsedArgs.debugFlags, rlimits);   
  45.         } catch (IllegalArgumentException ex) {   
  46.             ......   
  47.         } catch (ZygoteSecurityException ex) {   
  48.             ......   
  49.         }   
  50.    
  51.         if (pid == 0) {   
  52.             // in child   
  53.             handleChildProc(parsedArgs, descriptors, newStderr);   
  54.             // should never happen   
  55.             return true;   
  56.         } else { /* pid != 0 */   
  57.             // in parent...pid of < 0 means failure   
  58.             return handleParentProc(pid, descriptors, parsedArgs);   
  59.         }   
  60.     }   
  61.    
  62.     ......   
  63. }   
 
      真正创建进程的地方就是在这里了:
  
  
  
  
  1. pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid,   
  2.     parsedArgs.gids, parsedArgs.debugFlags, rlimits);   
       有Linux开发经验的读者很容易看懂这个函数调用,这个函数会创建一个进程,而且有两个返回值,一个是在当前进程中返回的,一个是在新创建的进程中返回,即在当前进程的子进程中返回,在当前进程中的返回值就是新创建的子进程的pid值,而在子进程中的返回值是0。因为我们只关心创建的新进程的情况,因此,我们沿着子进程的执行路径继续看下去:
  
  
  
  
  1.    if (pid == 0) {   
  2. // in child   
  3. handleChildProc(parsedArgs, descriptors, newStderr);   
  4. // should never happen   
  5. return true;   
  6.    } else { /* pid != 0 */   
  7. ......   
  8.    }   
       这里就是调用handleChildProc函数了。
        Step 7. ZygoteConnection.handleChildProc
        这个函数定义在frameworks/base/core/java/com/android/internal/os/ZygoteConnection.java文件中:
  
  
  
  
  1. class ZygoteConnection {   
  2.     ......   
  3.    
  4.     private void handleChildProc(Arguments parsedArgs,   
  5.             FileDescriptor[] descriptors, PrintStream newStderr)   
  6.             throws ZygoteInit.MethodAndArgsCaller {   
  7.         ......   
  8.    
  9.         if (parsedArgs.runtimeInit) {   
  10.             RuntimeInit.zygoteInit(parsedArgs.remainingArgs);   
  11.         } else {   
  12.             ......   
  13.         }   
  14.     }   
  15.    
  16.     ......   
  17. }   
 
     由于在前面的Step 3中,指定了"--runtime-init"参数,表示要为新创建的进程初始化运行时库,因此,这里的parseArgs.runtimeInit值为true,于是就继续执行RuntimeInit.zygoteInit进一步处理了。
        Step 8. RuntimeInit.zygoteInit
        这个函数定义在frameworks/base/core/java/com/android/internal/os/RuntimeInit.java文件中:
  1. public class RuntimeInit {  
  2.     ......  
  3.   
  4.     public static final void zygoteInit(String[] argv)  
  5.             throws ZygoteInit.MethodAndArgsCaller {  
  6.         // TODO: Doing this here works, but it seems kind of arbitrary. Find  
  7.         // a better place. The goal is to set it up for applications, but not  
  8.         // tools like am.  
  9.         System.setOut(new AndroidPrintStream(Log.INFO, "System.out"));  
  10.         System.setErr(new AndroidPrintStream(Log.WARN, "System.err"));  
  11.   
  12.         commonInit();  
  13.         zygoteInitNative();  
  14.   
  15.         int curArg = 0;  
  16.         for ( /* curArg */ ; curArg < argv.length; curArg++) {  
  17.             String arg = argv[curArg];  
  18.   
  19.             if (arg.equals("--")) {  
  20.                 curArg++;  
  21.                 break;  
  22.             } else if (!arg.startsWith("--")) {  
  23.                 break;  
  24.             } else if (arg.startsWith("--nice-name=")) {  
  25.                 String niceName = arg.substring(arg.indexOf('=') + 1);  
  26.                 Process.setArgV0(niceName);  
  27.             }  
  28.         }  
  29.   
  30.         if (curArg == argv.length) {  
  31.             Slog.e(TAG, "Missing classname argument to RuntimeInit!");  
  32.             // let the process exit  
  33.             return;  
  34.         }  
  35.   
  36.         // Remaining arguments are passed to the start class's static main  
  37.   
  38.         String startClass = argv[curArg++];  
  39.         String[] startArgs = new String[argv.length - curArg];  
  40.   
  41.         System.arraycopy(argv, curArg, startArgs, 0, startArgs.length);  
  42.         invokeStaticMain(startClass, startArgs);  
  43.     }  
  44.   
  45.     ......  
  46. }  
        这里有两个关键的函数调用,一个是zygoteInitNative函数调用,一个是invokeStaticMain函数调用,前者就是执行Binder驱动程序初始化的相关工作了,正是由于执行了这个工作,才使得进程中的Binder对象能够顺利地进行Binder进程间通信,而后一个函数调用,就是执行进程的入口函数,这里就是执行startClass类的main函数了,而这个startClass即是我们在Step 1中传进来的"android.app.ActivityThread"值,表示要执行android.app.ActivityThread类的main函数。
 
        我们先来看一下zygoteInitNative函数的调用过程,然后再回到RuntimeInit.zygoteInit函数中来,看看它是如何调用android.app.ActivityThread类的main函数的。
        step 9. RuntimeInit.zygoteInitNative
        这个函数定义在frameworks/base/core/java/com/android/internal/os/RuntimeInit.java文件中:
 
[java]  view plain copy
  1. public class RuntimeInit {  
  2.     ......  
  3.   
  4.     public static final native void zygoteInitNative();  
  5.   
  6.     ......  
  7. }  
        这里可以看出,函数zygoteInitNative是一个Native函数,实现在frameworks/base/core/jni/AndroidRuntime.cpp文件中:
 
 
[cpp]  view plain copy
  1. static void com_android_internal_os_RuntimeInit_zygoteInit(JNIEnv* env, jobject clazz)  
  2. {  
  3.     gCurRuntime->onZygoteInit();  
  4. }  
 
        这里它调用了全局变量gCurRuntime的onZygoteInit函数,这个全局变量的定义在frameworks/base/core/jni/AndroidRuntime.cpp文件开头的地方:
 
[cpp]  view plain copy
  1. static AndroidRuntime* gCurRuntime = NULL;  
        这里可以看出,它的类型为AndroidRuntime,它是在AndroidRuntime类的构造函数中初始化的,AndroidRuntime类的构造函数也是定义在frameworks/base/core/jni/AndroidRuntime.cpp文件中:
 
 
[cpp]  view plain copy
  1. AndroidRuntime::AndroidRuntime()  
  2. {  
  3.     ......  
  4.   
  5.     assert(gCurRuntime == NULL);        // one per process  
  6.     gCurRuntime = this;  
  7. }  
        那么这个AndroidRuntime类的构造函数又是什么时候被调用的呢?AndroidRuntime类的声明在frameworks/base/include/android_runtime/AndroidRuntime.h文件中,如果我们打开这个文件会看到,它是一个虚拟类,也就是我们不能直接创建一个AndroidRuntime对象,只能用一个AndroidRuntime类的指针来指向它的某一个子类,这个子类就是AppRuntime了,它定义在frameworks/base/cmds/app_process/app_main.cpp文件中:
 
 
[cpp]  view plain copy
  1. int main(int argc, const charconst argv[])  
  2. {  
  3.     ......  
  4.   
  5.     AppRuntime runtime;  
  6.       
  7.     ......  
  8. }  
        而AppRuntime类继续了AndroidRuntime类,它也是定义在frameworks/base/cmds/app_process/app_main.cpp文件中:
[cpp]  view plain copy
  1. class AppRuntime : public AndroidRuntime  
  2. {  
  3.     ......  
  4.   
  5. };  
        因此,在前面的com_android_internal_os_RuntimeInit_zygoteInit函数,实际是执行了AppRuntime类的onZygoteInit函数。
 
 
 

你可能感兴趣的:(android,应用程序,源代码分析,进程启动过程)