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,如需转载请自行联系原作者
目录
相关文章
|
2月前
|
开发框架 前端开发 Android开发
Flutter 与原生模块(Android 和 iOS)之间的通信机制,包括方法调用、事件传递等,分析了通信的必要性、主要方式、数据传递、性能优化及错误处理,并通过实际案例展示了其应用效果,展望了未来的发展趋势
本文深入探讨了 Flutter 与原生模块(Android 和 iOS)之间的通信机制,包括方法调用、事件传递等,分析了通信的必要性、主要方式、数据传递、性能优化及错误处理,并通过实际案例展示了其应用效果,展望了未来的发展趋势。这对于实现高效的跨平台移动应用开发具有重要指导意义。
209 4
|
2月前
|
安全 Android开发 数据安全/隐私保护
深入探讨iOS与Android系统安全性对比分析
在移动操作系统领域,iOS和Android无疑是两大巨头。本文从技术角度出发,对这两个系统的架构、安全机制以及用户隐私保护等方面进行了详细的比较分析。通过深入探讨,我们旨在揭示两个系统在安全性方面的差异,并为用户提供一些实用的安全建议。
|
1月前
|
Java 开发工具 Android开发
安卓与iOS开发环境对比分析
在移动应用开发的广阔天地中,安卓和iOS两大平台各自占据半壁江山。本文深入探讨了这两个平台的开发环境,从编程语言、开发工具到用户界面设计等多个角度进行比较。通过实际案例分析和代码示例,我们旨在为开发者提供一个清晰的指南,帮助他们根据项目需求和个人偏好做出明智的选择。无论你是初涉移动开发领域的新手,还是寻求跨平台解决方案的资深开发者,这篇文章都将为你提供宝贵的信息和启示。
32 8
|
1月前
|
调度 开发者
核心概念解析:进程与线程的对比分析
在操作系统和计算机编程领域,进程和线程是两个基本而核心的概念。它们是程序执行和资源管理的基础,但它们之间存在显著的差异。本文将深入探讨进程与线程的区别,并分析它们在现代软件开发中的应用和重要性。
57 4
|
3月前
|
缓存 Java Shell
Android 系统缓存扫描与清理方法分析
Android 系统缓存从原理探索到实现。
94 15
Android 系统缓存扫描与清理方法分析
|
2月前
|
安全 Android开发 数据安全/隐私保护
深入探索Android与iOS系统安全性的对比分析
在当今数字化时代,移动操作系统的安全已成为用户和开发者共同关注的重点。本文旨在通过比较Android与iOS两大主流操作系统在安全性方面的差异,揭示两者在设计理念、权限管理、应用审核机制等方面的不同之处。我们将探讨这些差异如何影响用户的安全体验以及可能带来的风险。
45 1
|
2月前
|
运维 JavaScript jenkins
鸿蒙5.0版开发:分析CppCrash(进程崩溃)
在HarmonyOS 5.0中,CppCrash指C/C++运行时崩溃,常见原因包括空指针、数组越界等。系统提供基于posix信号机制的异常检测能力,生成详细日志辅助定位。本文详解CppCrash分析方法,涵盖异常检测、问题定位思路及案例分析。
66 4
|
2月前
|
运维 监控 JavaScript
鸿蒙next版开发:分析JS Crash(进程崩溃)
在HarmonyOS 5.0中,JS Crash指未处理的JavaScript异常导致应用意外退出。本文详细介绍如何分析JS Crash,包括异常捕获、日志分析和典型案例,帮助开发者定位问题、修复错误,提升应用稳定性。通过DevEco Studio收集日志,结合HiChecker工具,有效解决JS Crash问题。
67 4
|
3月前
|
存储 Linux Android开发
Android底层:通熟易懂分析binder:1.binder准备工作
本文详细介绍了Android Binder机制的准备工作,包括打开Binder驱动、内存映射(mmap)、启动Binder主线程等内容。通过分析系统调用和进程与驱动层的通信,解释了Binder如何实现进程间通信。文章还探讨了Binder主线程的启动流程及其在进程通信中的作用,最后总结了Binder准备工作的调用时机和重要性。
Android底层:通熟易懂分析binder:1.binder准备工作
|
4月前
|
安全 Android开发 数据安全/隐私保护
探索安卓与iOS的安全性差异:技术深度分析与实践建议
本文旨在深入探讨并比较Android和iOS两大移动操作系统在安全性方面的不同之处。通过详细的技术分析,揭示两者在架构设计、权限管理、应用生态及更新机制等方面的安全特性。同时,针对这些差异提出针对性的实践建议,旨在为开发者和用户提供增强移动设备安全性的参考。
163 3
AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等