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. publicfinalclassActivityManagerServiceextendsActivityManagerNative
    2.             
  2. implementsWatchdog.Monitor,BatteryStatsImpl.BatteryCallback{
    3.             
    4.             
  4. ......
    5.             
    6.             
  6. privatefinalvoidstartProcessLocked(ProcessRecordapp,
    7.             
  7. StringhostingType,StringhostingNameStr){
    8.             
    9.             
  9. ......
    10.             
    11.             
  11. try{
    12.             
  12. intuid=app.info.uid;
    13.             
  13. int[]gids=null;
    14.             
  14. try{
    15.             
  15. gids=mContext.getPackageManager().getPackageGids(
    16.             
  16. app.info.packageName);
    17.             
  17. }catch(PackageManager.NameNotFoundExceptione){
    18.             
  18. ......
    19.             
  19. }
    20.             
    21.             
  21. ......
    22.             
    23.             
  23. intdebugFlags=0;
    24.             
    25.             
  25. ......
    26.             
    27.             
  27. intpid=Process.start("android.app.ActivityThread",
    28.             
  28. mSimpleProcessManagement?app.processName:null,uid,uid,
    29.             
  29. gids,debugFlags,null);
    30.             
    31.             
  31. ......
    32.             
    33.             
  33. }catch(RuntimeExceptione){
    34.             
    35.             
  35. ......
    36.             
    37.             
  37. }
    38.             
  38. }
    39.             
    40.             
  40. ......
    41.             
    42.             
  42. }
    43.

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

Step 2. Process.start

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

        
                
  1. publicclassProcess{
    2.             
  2. ......
    3.             
    4.             
  4. publicstaticfinalintstart(finalStringprocessClass,
    5.             
  5. finalStringniceName,
    6.             
  6. intuid,intgid,int[]gids,
    7.             
  7. intdebugFlags,
    8.             
  8. String[]zygoteArgs)
    9.             
  9. {
    10.             
  10. if(supportsProcesses()){
    11.             
  11. try{
    12.             
  12. returnstartViaZygote(processClass,niceName,uid,gid,gids,
    13.             
  13. debugFlags,zygoteArgs);
    14.             
  14. }catch(ZygoteStartFailedExex){
    15.             
  15. ......
    16.             
  16. }
    17.             
  17. }else{
    18.             
  18. ......
    19.             
    20.             
  20. return0;
    21.             
  21. }
    22.             
  22. }
    23.             
    24.             
  24. ......
    25.             
  25. }
    26.

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

        
                
  1. jbooleanandroid_os_Process_supportsProcesses(JNIEnv*env,jobjectclazz)
    2.             
  2. {
    3.             
  3. returnProcessState::self()->supportsProcesses();
    4.             
  4. }
    5.

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

        
                
  1. boolProcessState::supportsProcesses()const
    2.             
  2. {
    3.             
  3. returnmDriverFD>=0;
    4.             
  4. }
    5.

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

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

Step 3.Process.startViaZygote

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

        
                
  1. publicclassProcess{
    2.             
  2. ......
    3.             
    4.             
  4. privatestaticintstartViaZygote(finalStringprocessClass,
    5.             
  5. finalStringniceName,
    6.             
  6. finalintuid,finalintgid,
    7.             
  7. finalint[]gids,
    8.             
  8. intdebugFlags,
    9.             
  9. String[]extraArgs)
    10.             
  10. throwsZygoteStartFailedEx{
    11.             
  11. intpid;
    12.             
    13.             
  13. synchronized(Process.class){
    14.             
  14. ArrayList<String>argsForZygote=newArrayList<String>();
    15.             
    16.             
  16. //--runtime-init,--setuid=,--setgid=,
    17.             
  17. //and--setgroups=mustgofirst
    18.             
  18. argsForZygote.add("--runtime-init");
    19.             
  19. argsForZygote.add("--setuid="+uid);
    20.             
  20. argsForZygote.add("--setgid="+gid);
    21.             
  21. if((debugFlags&Zygote.DEBUG_ENABLE_SAFEMODE)!=0){
    22.             
  22. argsForZygote.add("--enable-safemode");
    23.             
  23. }
    24.             
  24. if((debugFlags&Zygote.DEBUG_ENABLE_DEBUGGER)!=0){
    25.             
  25. argsForZygote.add("--enable-debugger");
    26.             
  26. }
    27.             
  27. if((debugFlags&Zygote.DEBUG_ENABLE_CHECKJNI)!=0){
    28.             
  28. argsForZygote.add("--enable-checkjni");
    29.             
  29. }
    30.             
  30. if((debugFlags&Zygote.DEBUG_ENABLE_ASSERT)!=0){
    31.             
  31. argsForZygote.add("--enable-assert");
    32.             
  32. }
    33.             
    34.             
  34. //TODOoptionallyenabledebuger
    35.             
  35. //argsForZygote.add("--enable-debugger");
    36.             
    37.             
  37. //--setgroupsisacomma-separatedlist
    38.             
  38. if(gids!=null&&gids.length>0){
    39.             
  39. StringBuildersb=newStringBuilder();
    40.             
  40. sb.append("--setgroups=");
    41.             
    42.             
  42. intsz=gids.length;
    43.             
  43. for(inti=0;i<sz;i++){
    44.             
  44. if(i!=0){
    45.             
  45. sb.append(',');
    46.             
  46. }
    47.             
  47. sb.append(gids[i]);
    48.             
  48. }
    49.             
    50.             
  50. argsForZygote.add(sb.toString());
    51.             
  51. }
    52.             
    53.             
  53. if(niceName!=null){
    54.             
  54. argsForZygote.add("--nice-name="+niceName);
    55.             
  55. }
    56.             
    57.             
  57. argsForZygote.add(processClass);
    58.             
    59.             
  59. if(extraArgs!=null){
    60.             
  60. for(Stringarg:extraArgs){
    61.             
  61. argsForZygote.add(arg);
    62.             
  62. }
    63.             
  63. }
    64.             
    65.             
  65. pid=zygoteSendArgsAndGetPid(argsForZygote);
    66.             
  66. }
    67.             
  67. }
    68.             
    69.             
  69. ......
    70.             
  70. }
    71.

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

Step 4. Process.zygoteSendAndGetPid

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

        
                
  1. publicclassProcess{
    2.             
  2. ......
    3.             
    4.             
  4. privatestaticintzygoteSendArgsAndGetPid(ArrayList<String>args)
    5.             
  5. throwsZygoteStartFailedEx{
    6.             
  6. intpid;
    7.             
    8.             
  8. openZygoteSocketIfNeeded();
    9.             
    10.             
  10. try{
    11.             
  11. /**
    12.             
  12. *Seecom.android.internal.os.ZygoteInit.readArgumentList()
    13.             
  13. *Presentlythewireformattothezygoteprocessis:
    14.             
  14. *a)acountofarguments(argc,inessence)
    15.             
  15. *b)anumberofnewline-separatedargumentstringsequaltocount
    16.             
  16. *
    17.             
  17. *Afterthezygoteprocessreadstheseitwillwritethepidof
    18.             
  18. *thechildor-1onfailure.
    19.             
  19. */
    20.             
    21.             
  21. sZygoteWriter.write(Integer.toString(args.size()));
    22.             
  22. sZygoteWriter.newLine();
    23.             
    24.             
  24. intsz=args.size();
    25.             
  25. for(inti=0;i<sz;i++){
    26.             
  26. Stringarg=args.get(i);
    27.             
  27. if(arg.indexOf('\n')>=0){
    28.             
  28. thrownewZygoteStartFailedEx(
    29.             
  29. "embeddednewlinesnotallowed");
    30.             
  30. }
    31.             
  31. sZygoteWriter.write(arg);
    32.             
  32. sZygoteWriter.newLine();
    33.             
  33. }
    34.             
    35.             
  35. sZygoteWriter.flush();
    36.             
    37.             
  37. //Shouldtherebeatimeoutonthis?
    38.             
  38. pid=sZygoteInputStream.readInt();
    39.             
    40.             
  40. if(pid<0){
    41.             
  41. thrownewZygoteStartFailedEx("fork()failed");
    42.             
  42. }
    43.             
  43. }catch(IOExceptionex){
    44.             
  44. ......
    45.             
  45. }
    46.             
    47.             
  47. returnpid;
    48.             
  48. }
    49.             
    50.             
  50. ......
    51.             
  51. }
    52.

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

        
                
  1. publicclassProcess{
    2.             
  2. ......
    3.             
    4.             
  4. /**
    5.             
  5. *TriestoopensockettoZygoteprocessifnotalreadyopen.If
    6.             
  6. *alreadyopen,doesnothing.Mayblockandretry.
    7.             
  7. */
    8.             
  8. privatestaticvoidopenZygoteSocketIfNeeded()
    9.             
  9. throwsZygoteStartFailedEx{
    10.             
    11.             
  11. intretryCount;
    12.             
    13.             
  13. if(sPreviousZygoteOpenFailed){
    14.             
  14. /*
    15.             
  15. *Ifwe'vefailedbefore,expectthatwe'llfailagainand
    16.             
  16. *don'tpauseforretries.
    17.             
  17. */
    18.             
  18. retryCount=0;
    19.             
  19. }else{
    20.             
  20. retryCount=10;
    21.             
  21. }
    22.             
    23.             
  23. /*
    24.             
  24. *Seebug#811181:Sometimesruntimecanmakeitupbeforezygote.
    25.             
  25. *Really,we'dliketodosomethingbettertoavoidthiscondition,
    26.             
  26. *butfornowjustwaitabit...
    27.             
  27. */
    28.             
  28. for(intretry=0
    29.             
  29. ;(sZygoteSocket==null)&&(retry<(retryCount+1))
    30.             
  30. ;retry++){
    31.             
    32.             
  32. if(retry>0){
    33.             
  33. try{
    34.             
  34. Log.i("Zygote","Zygotenotupyet,sleeping...");
    35.             
  35. Thread.sleep(ZYGOTE_RETRY_MILLIS);
    36.             
  36. }catch(InterruptedExceptionex){
    37.             
  37. //shouldneverhappen
    38.             
  38. }
    39.             
  39. }
    40.             
    41.             
  41. try{
    42.             
  42. sZygoteSocket=newLocalSocket();
    43.             
  43. sZygoteSocket.connect(newLocalSocketAddress(ZYGOTE_SOCKET,
    44.             
  44. LocalSocketAddress.Namespace.RESERVED));
    45.             
    46.             
  46. sZygoteInputStream
    47.             
  47. =newDataInputStream(sZygoteSocket.getInputStream());
    48.             
    49.             
  49. sZygoteWriter=
    50.             
  50. newBufferedWriter(
    51.             
  51. newOutputStreamWriter(
    52.             
  52. sZygoteSocket.getOutputStream()),
    53.             
  53. 256);
    54.             
    55.             
  55. Log.i("Zygote","Process:zygotesocketopened");
    56.             
    57.             
  57. sPreviousZygoteOpenFailed=false;
    58.             
  58. break;
    59.             
  59. }catch(IOExceptionex){
    60.             
  60. ......
    61.             
  61. }
    62.             
  62. }
    63.             
    64.             
  64. ......
    65.             
  65. }
    66.             
    67.             
  67. ......
    68.             
  68. }
    69.

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

更多相关文章

  1. 箭头函数的基础使用
  2. Python技巧匿名函数、回调函数和高阶函数
  3. 【android内核分析-启动】Android(安卓)启动过程详解
  4. Android(安卓)AIDL 跨进程服务 Proxy/Stub
  5. Android(安卓)第一课——Android架构
  6. Android应用程序注册广播接收器（registerReceiver）的过程分析
  7. Android(安卓)操作系统的内存回收机制
  8. Android应用程序注册广播接收器（registerReceiver）的过程分析
  9. Android(安卓)无线接口层RIL（Radio Layer Interface）

随机推荐

  1. java中匹配字符串中的中文字符(含中文标
  2. Java nio 学习笔记（一） Buffer（缓冲区）与Chan
  3. 如何知道Object是否为String类型对象？
  4. Java实现图像对比类
  5. Eclipse Juno 4.2的Swing插件[重复]
  6. 关于JAVA类加载大家发表一下见解吧
  7. Java标准标签库学习小结
  8. Javascript实现页面加载完成后自动刷新一
  9. tomcat启动报错问题！求帮忙看看
  10. javascript小例子--实现邮箱验证的功能