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

2017-11-05 600 收藏

     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 char* const 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函数。

 

本文转自 Luoshengyang 51CTO博客，原文链接：http://blog.51cto.com/，如需转载请自行联系原作者

上一篇 下一篇

微信关注我们

原文链接：https://yq.aliyun.com/articles/407469

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

Android启动流程（Java层）

写在前面的话 目前打算是先把Android的启动流程包括luncher、Activity的启动以及Service启动，View的绘制，事件分发等进行分析，后面应该还会包括现阶段正在使用的框架MVVM的分析。可能是更新Android不会太久了，有点迷茫Android的未来到底在哪里，把握现在吧。 今天这部分讲解的是Android系统启动后加载各种服务的过程。 1 init init是第一个进程，我们可以说它是root进程或者说有进程的父进程。init进程有两个责任，一是挂载目录，比如/sys、/dev、/proc，二是运行init.rc脚本。 init进程可以在/system/core/init找到。 init.rc文件可以在/system/core/rootdir/init.rc找到。 readme.txt可以在/system/core/init/readme.txt找到。 对于init.rc文件，Android中有特定的格式以及规则。在Android中，我们叫做Android初始化语言。 2 Zygote加载进程 Zygote本意是受精卵，Android中可以理解为孵化器。Andro...

2017-11-05

625

上一篇

Android学习 - (2)打造Android版手机视频监控系统

接上一篇博文, 来继续完善这个例子; 主要是新增了2个Activity, 显示设备与视频通道的TreeActivity, 浏览某一个通道的实时画面的ImageActivity. TreeActivity主要就是使用一个ListView控件按层次关系来显示区域、设备、视频通道信息。主要涉及以下几个方面知识点： 1、通过HTTP POST方式获取服务端响应的JSON格式数据 json格式当前被大量应用于web数据传输，你可以在这里了解什么是json；因为服务端采用Java开发，可以采用的json库很多，比较常见的如org.json（不需要额外的jar包，Android内置json格式数据解析包就是这个；但好像对自定义实体类支持不太好，也有可能是我不会用，因为以前做web开发都是采用xml来传输服务端响应的数据），json-lib（功能强大，但需要附带一些其他jar包，其通过反射方式来实现对用户自定义bean支持），最终啥都没有采用，直接Override toString() 方法简单处理下。 代码 @Override public StringtoString() { if (entT...

2017-11-05

475

下一篇

相关文章

发表评论

发表

资源下载

更多资源

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

时间: 2026-04-24 大小: 189MB 下载: 6次

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

时间: 2025-12-17 大小: 5MB 下载: 1次

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。

时间: 2025-12-03 大小: 9.84MB 下载: 39次

WebStorm

WebStorm 是jetbrains公司旗下一款JavaScript 开发工具。目前已经被广大中国JS开发者誉为“Web前端开发神器”、“最强大的HTML5编辑器”、“最智能的JavaScript IDE”等。与IntelliJ IDEA同源，继承了IntelliJ IDEA强大的JS部分的功能。

时间: 2025-12-13 大小: 249.54MB 下载: 22次