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

简介:

Android应用程序框架层创建的应用程序进程具有两个特点,一是进程的入口函数是ActivityThread.main,二是进程天然支持Binder进程间通信机制;这两个特点都是在进程的初始化过程中实现的,本文将详细分析Android应用程序进程创建过程中是如何实现这两个特点的。

        Android应用程序框架层创建的应用程序进程的入口函数是ActivityThread.main比较好理解,即进程创建完成之后,Android应用程序框架层就会在这个进程中将ActivityThread类加载进来,然后执行它的main函数,这个main函数就是进程执行消息循环的地方了。Android应用程序框架层创建的应用程序进程天然支持Binder进程间通信机制这个特点应该怎么样理解呢?前面我们在学习Android系统的Binder进程间通信机制时说到,它具有四个组件,分别是驱动程序、守护进程、Client以及Server,其中Server组件在初始化时必须进入一个循环中不断地与Binder驱动程序进行到交互,以便获得Client组件发送的请求,具体可参考Android系统进程间通信(IPC)机制Binder中的Server启动过程源代码分析一文,但是,当我们在Android应用程序中实现Server组件的时候,我们并没有让进程进入一个循环中去等待Client组件的请求,然而,当Client组件得到这个Server组件的远程接口时,却可以顺利地和Server组件进行进程间通信,这就是因为Android应用程序进程在创建的时候就已经启动了一个线程池来支持Server组件和Binder驱动程序之间的交互了,这样,极大地方便了在Android应用程序中创建Server组件。

        在Android应用程序框架层中,是由ActivityManagerService组件负责为Android应用程序创建新的进程的,它本来也是运行在一个独立的进程之中,不过这个进程是在系统启动的过程中创建的。ActivityManagerService组件一般会在什么情况下会为应用程序创建一个新的进程呢?当系统决定要在一个新的进程中启动一个Activity或者Service时,它就会创建一个新的进程了,然后在这个新的进程中启动这个Activity或者Service,具体可以参考Android系统在新进程中启动自定义服务过程(startService)的原理分析、Android应用程序启动过程源代码分析和Android应用程序在新的进程中启动新的Activity的方法和过程分析这三篇文章。

        ActivityManagerService启动新的进程是从其成员函数startProcessLocked开始的,在深入分析这个过程之前,我们先来看一下进程创建过程的序列图,然后再详细分析每一个步骤。

        Step 1. ActivityManagerService.startProcessLocked

        这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java文件中:


  
  
  1. public final class ActivityManagerService extends ActivityManagerNative     
  2.         implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {     
  3.      
  4.     ......     
  5.      
  6.     private final void startProcessLocked(ProcessRecord app,     
  7.                 String hostingType, String hostingNameStr) {     
  8.      
  9.         ......     
  10.      
  11.         try {     
  12.             int uid = app.info.uid;     
  13.             int[] gids = null;     
  14.             try {     
  15.                 gids = mContext.getPackageManager().getPackageGids(     
  16.                     app.info.packageName);     
  17.             } catch (PackageManager.NameNotFoundException e) {     
  18.                 ......     
  19.             }     
  20.                  
  21.             ......     
  22.      
  23.             int debugFlags = 0;     
  24.                  
  25.             ......     
  26.                  
  27.             int pid = Process.start("android.app.ActivityThread",     
  28.                 mSimpleProcessManagement ? app.processName : null, uid, uid,     
  29.                 gids, debugFlags, null);     
  30.                  
  31.             ......     
  32.      
  33.         } catch (RuntimeException e) {     
  34.                  
  35.             ......     
  36.      
  37.         }     
  38.     }     
  39.      
  40.     ......     
  41.      
  42. }     

       它调用了Process.start函数开始为应用程序创建新的进程,注意,它传入一个第一个参数为"android.app.ActivityThread",这就是进程初始化时要加载的Java类了,把这个类加载到进程之后,就会把它里面的静态成员函数main作为进程的入口点,后面我们会看到。

 

        Step 2. Process.start 

        这个函数定义在frameworks/base/core/java/android/os/Process.java文件中:


  
  
  1. public class Process {   
  2.     ......   
  3.    
  4.     public static final int start(final String processClass,   
  5.         final String niceName,   
  6.         int uid, int gid, int[] gids,   
  7.         int debugFlags,   
  8.         String[] zygoteArgs)   
  9.     {   
  10.         if (supportsProcesses()) {   
  11.             try {   
  12.                 return startViaZygote(processClass, niceName, uid, gid, gids,   
  13.                     debugFlags, zygoteArgs);   
  14.             } catch (ZygoteStartFailedEx ex) {   
  15.                 ......   
  16.             }   
  17.         } else {   
  18.             ......   
  19.    
  20.             return 0;   
  21.         }   
  22.     }   
  23.    
  24.     ......   
  25. }   

       这里的supportsProcesses函数返回值为true,它是一个Native函数,实现在frameworks/base/core/jni/android_util_Process.cpp文件中:


  
  
  1. jboolean android_os_Process_supportsProcesses(JNIEnv* env, jobject clazz)   
  2. {   
  3.     return ProcessState::self()->supportsProcesses();   
  4. }   

  ProcessState::supportsProcesses函数定义在frameworks/base/libs/binder/ProcessState.cpp文件中:


  
  
  1. bool ProcessState::supportsProcesses() const   
  2. {   
  3.     return mDriverFD >= 0;   
  4. }   

       这里的mDriverFD是设备文件/dev/binder的打开描述符,如果成功打开了这个设备文件,那么它的值就会大于等于0,因此,它的返回值为true。

 

       回到Process.start函数中,它调用startViaZygote函数进一步操作。

       Step 3. Process.startViaZygote

       这个函数定义在frameworks/base/core/java/android/os/Process.java文件中:


  
  
  1. public class Process {   
  2.     ......   
  3.    
  4.     private static int startViaZygote(final String processClass,   
  5.             final String niceName,   
  6.             final int uid, final int gid,   
  7.             final int[] gids,   
  8.             int debugFlags,   
  9.             String[] extraArgs)   
  10.             throws ZygoteStartFailedEx {   
  11.         int pid;   
  12.    
  13.         synchronized(Process.class) {   
  14.             ArrayList<String> argsForZygote = new ArrayList<String>();   
  15.    
  16.             // --runtime-init, --setuid=, --setgid=,   
  17.             // and --setgroups= must go first   
  18.             argsForZygote.add("--runtime-init");   
  19.             argsForZygote.add("--setuid=" + uid);   
  20.             argsForZygote.add("--setgid=" + gid);   
  21.             if ((debugFlags & Zygote.DEBUG_ENABLE_SAFEMODE) != 0) {   
  22.                 argsForZygote.add("--enable-safemode");   
  23.             }   
  24.             if ((debugFlags & Zygote.DEBUG_ENABLE_DEBUGGER) != 0) {   
  25.                 argsForZygote.add("--enable-debugger");   
  26.             }   
  27.             if ((debugFlags & Zygote.DEBUG_ENABLE_CHECKJNI) != 0) {   
  28.                 argsForZygote.add("--enable-checkjni");   
  29.             }   
  30.             if ((debugFlags & Zygote.DEBUG_ENABLE_ASSERT) != 0) {   
  31.                 argsForZygote.add("--enable-assert");   
  32.             }   
  33.    
  34.             //TODO optionally enable debuger   
  35.             //argsForZygote.add("--enable-debugger");   
  36.    
  37.             // --setgroups is a comma-separated list   
  38.             if (gids != null && gids.length > 0) {   
  39.                 StringBuilder sb = new StringBuilder();   
  40.                 sb.append("--setgroups=");   
  41.    
  42.                 int sz = gids.length;   
  43.                 for (int i = 0; i < sz; i++) {   
  44.                     if (i != 0) {   
  45.                         sb.append(',');   
  46.                     }   
  47.                     sb.append(gids[i]);   
  48.                 }   
  49.    
  50.                 argsForZygote.add(sb.toString());   
  51.             }   
  52.    
  53.             if (niceName != null) {   
  54.                 argsForZygote.add("--nice-name=" + niceName);   
  55.             }   
  56.    
  57.             argsForZygote.add(processClass);   
  58.    
  59.             if (extraArgs != null) {   
  60.                 for (String arg : extraArgs) {   
  61.                     argsForZygote.add(arg);   
  62.                 }   
  63.             }   
  64.    
  65.             pid = zygoteSendArgsAndGetPid(argsForZygote);   
  66.         }   
  67.     }   
  68.    
  69.     ......   
  70. }   

       这个函数将创建进程的参数放到argsForZygote列表中去,如参数"--runtime-init"表示要为新创建的进程初始化运行时库,然后调用zygoteSendAndGetPid函数进一步操作。

 

        Step 4. Process.zygoteSendAndGetPid

        这个函数定义在frameworks/base/core/java/android/os/Process.java文件中:


  
  
  1. public class Process {   
  2.     ......   
  3.    
  4.     private static int zygoteSendArgsAndGetPid(ArrayList<String> args)   
  5.             throws ZygoteStartFailedEx {   
  6.         int pid;   
  7.    
  8.         openZygoteSocketIfNeeded();   
  9.    
  10.         try {   
  11.             /**  
  12.             * See com.android.internal.os.ZygoteInit.readArgumentList()  
  13.             * Presently the wire format to the zygote process is:  
  14.             * a) a count of arguments (argc, in essence)  
  15.             * b) a number of newline-separated argument strings equal to count  
  16.             *  
  17.             * After the zygote process reads these it will write the pid of  
  18.             * the child or -1 on failure.  
  19.             */   
  20.    
  21.             sZygoteWriter.write(Integer.toString(args.size()));   
  22.             sZygoteWriter.newLine();   
  23.    
  24.             int sz = args.size();   
  25.             for (int i = 0; i < sz; i++) {   
  26.                 String arg = args.get(i);   
  27.                 if (arg.indexOf('\n') >= 0) {   
  28.                     throw new ZygoteStartFailedEx(   
  29.                         "embedded newlines not allowed");   
  30.                 }   
  31.                 sZygoteWriter.write(arg);   
  32.                 sZygoteWriter.newLine();   
  33.             }   
  34.    
  35.             sZygoteWriter.flush();   
  36.    
  37.             // Should there be a timeout on this?   
  38.             pid = sZygoteInputStream.readInt();   
  39.    
  40.             if (pid < 0) {   
  41.                 throw new ZygoteStartFailedEx("fork() failed");   
  42.             }   
  43.         } catch (IOException ex) {   
  44.             ......   
  45.         }   
  46.    
  47.         return pid;   
  48.     }   
  49.    
  50.     ......   
  51. }   

         这里的sZygoteWriter是一个Socket写入流,是由openZygoteSocketIfNeeded函数打开的:


  
  
  1. public class Process {   
  2.     ......   
  3.    
  4.     /**  
  5.     * Tries to open socket to Zygote process if not already open. If  
  6.     * already open, does nothing.  May block and retry.  
  7.     */   
  8.     private static void openZygoteSocketIfNeeded()   
  9.             throws ZygoteStartFailedEx {   
  10.    
  11.         int retryCount;   
  12.    
  13.         if (sPreviousZygoteOpenFailed) {   
  14.             /*  
  15.             * If we've failed before, expect that we'll fail again and  
  16.             * don't pause for retries.  
  17.             */   
  18.             retryCount = 0;   
  19.         } else {   
  20.             retryCount = 10;   
  21.         }   
  22.        
  23.         /*  
  24.         * See bug #811181: Sometimes runtime can make it up before zygote.  
  25.         * Really, we'd like to do something better to avoid this condition,  
  26.         * but for now just wait a bit...  
  27.         */   
  28.         for (int retry = 0   
  29.             ; (sZygoteSocket == null) && (retry < (retryCount + 1))   
  30.             ; retry++ ) {   
  31.    
  32.                 if (retry > 0) {   
  33.                     try {   
  34.                         Log.i("Zygote", "Zygote not up yet, sleeping...");   
  35.                         Thread.sleep(ZYGOTE_RETRY_MILLIS);   
  36.                     } catch (InterruptedException ex) {   
  37.                         // should never happen   
  38.                     }   
  39.                 }   
  40.    
  41.                 try {   
  42.                     sZygoteSocket = new LocalSocket();   
  43.                     sZygoteSocket.connect(new LocalSocketAddress(ZYGOTE_SOCKET,   
  44.                         LocalSocketAddress.Namespace.RESERVED));   
  45.    
  46.                     sZygoteInputStream   
  47.                         = new DataInputStream(sZygoteSocket.getInputStream());   
  48.    
  49.                     sZygoteWriter =   
  50.                         new BufferedWriter(   
  51.                         new OutputStreamWriter(   
  52.                         sZygoteSocket.getOutputStream()),   
  53.                         256);   
  54.    
  55.                     Log.i("Zygote", "Process: zygote socket opened");   
  56.    
  57.                     sPreviousZygoteOpenFailed = false;   
  58.                     break;   
  59.                 } catch (IOException ex) {   
  60.                     ......   
  61.                 }   
  62.         }   
  63.    
  64.         ......   
  65.     }   
  66.    
  67.     ......   
  68. }   

      这个Socket由frameworks/base/core/java/com/android/internal/os/ZygoteInit.java文件中的ZygoteInit类在runSelectLoopMode函数侦听的。







本文转自 Luoshengyang 51CTO博客,原文链接:http://blog.51cto.com/shyluo/966494,如需转载请自行联系原作者
目录
相关文章
Linux源码阅读笔记10-进程NICE案例分析2
Linux源码阅读笔记10-进程NICE案例分析2
|
弹性计算 运维 监控
基于进程热点分析与系统资源优化的智能运维实践
智能服务器管理平台提供直观的可视化界面,助力高效操作系统管理。核心功能包括运维监控、智能助手和扩展插件管理,支持系统健康监控、故障诊断等,确保集群稳定运行。首次使用需激活服务并安装管控组件。平台还提供进程热点追踪、性能观测与优化建议,帮助开发人员快速识别和解决性能瓶颈。定期分析和多维度监控可提前预警潜在问题,保障系统长期稳定运行。
773 17
|
调度 开发者
核心概念解析:进程与线程的对比分析
在操作系统和计算机编程领域,进程和线程是两个基本而核心的概念。它们是程序执行和资源管理的基础,但它们之间存在显著的差异。本文将深入探讨进程与线程的区别,并分析它们在现代软件开发中的应用和重要性。
750 4
|
运维 JavaScript jenkins
鸿蒙5.0版开发:分析CppCrash(进程崩溃)
在HarmonyOS 5.0中,CppCrash指C/C++运行时崩溃,常见原因包括空指针、数组越界等。系统提供基于posix信号机制的异常检测能力,生成详细日志辅助定位。本文详解CppCrash分析方法,涵盖异常检测、问题定位思路及案例分析。
868 4
|
运维 监控 JavaScript
鸿蒙next版开发:分析JS Crash(进程崩溃)
在HarmonyOS 5.0中,JS Crash指未处理的JavaScript异常导致应用意外退出。本文详细介绍如何分析JS Crash,包括异常捕获、日志分析和典型案例,帮助开发者定位问题、修复错误,提升应用稳定性。通过DevEco Studio收集日志,结合HiChecker工具,有效解决JS Crash问题。
1055 4
|
Java Android开发 数据安全/隐私保护
Android中多进程通信有几种方式?需要注意哪些问题?
本文介绍了Android中的多进程通信(IPC),探讨了IPC的重要性及其实现方式,如Intent、Binder、AIDL等,并通过一个使用Binder机制的示例详细说明了其实现过程。
1347 4
|
NoSQL Linux 程序员
进程管理与运行分析
进程管理与运行分析
266 0
|
并行计算 API 调度
探索Python中的并发编程:线程与进程的对比分析
【9月更文挑战第21天】本文深入探讨了Python中并发编程的核心概念,通过直观的代码示例和清晰的逻辑推理,引导读者理解线程与进程在解决并发问题时的不同应用场景。我们将从基础理论出发,逐步过渡到实际案例分析,旨在揭示Python并发模型的内在机制,并比较它们在执行效率、资源占用和适用场景方面的差异。文章不仅适合初学者构建并发编程的基础认识,同时也为有经验的开发者提供深度思考的视角。
|
Linux 数据库 Perl
【YashanDB 知识库】如何避免 yasdb 进程被 Linux OOM Killer 杀掉
本文来自YashanDB官网,探讨Linux系统中OOM Killer对数据库服务器的影响及解决方法。当内存接近耗尽时,OOM Killer会杀死占用最多内存的进程,这可能导致数据库主进程被误杀。为避免此问题,可采取两种方法:一是在OS层面关闭OOM Killer,通过修改`/etc/sysctl.conf`文件并重启生效;二是豁免数据库进程,由数据库实例用户借助`sudo`权限调整`oom_score_adj`值。这些措施有助于保护数据库进程免受系统内存管理机制的影响。
|
Linux Shell
Linux 进程前台后台切换与作业控制
进程前台/后台切换及作业控制简介: 在 Shell 中,启动的程序默认为前台进程,会占用终端直到执行完毕。例如,执行 `./shella.sh` 时,终端会被占用。为避免不便,可将命令放到后台运行,如 `./shella.sh &`,此时终端命令行立即返回,可继续输入其他命令。 常用作业控制命令: - `fg %1`:将后台作业切换到前台。 - `Ctrl + Z`:暂停前台作业并放到后台。 - `bg %1`:让暂停的后台作业继续执行。 - `kill %1`:终止后台作业。 优先级调整:
1920 5

热门文章

最新文章