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

最新推荐文章于 2025-08-22 08:41:08 发布
最新推荐文章于 2025-08-22 08:41:08 发布 · 30 阅读 · 0
文章标签：

#移动开发 #java #c/c++

本文详细分析了Android应用程序进程创建的过程，重点介绍了进程入口函数设置为ActivityThread.main以及进程内Binder IPC机制的初始化过程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

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文件中：

view plain
  1. publicfinalclassActivityManagerServiceextendsActivityManagerNative
  2. implementsWatchdog.Monitor,BatteryStatsImpl.BatteryCallback{
  4. ......
  6. privatefinalvoidstartProcessLocked(ProcessRecordapp,
  7. StringhostingType,StringhostingNameStr){
  9. ......
  11. try{
  12. intuid=app.info.uid;
  13. int[]gids=null;
  14. try{
  15. gids=mContext.getPackageManager().getPackageGids(
  16. app.info.packageName);
  17. }catch(PackageManager.NameNotFoundExceptione){
  18. ......
  19. }
  21. ......
  23. intdebugFlags=0;
  25. ......
  27. intpid=Process.start("android.app.ActivityThread",
  28. mSimpleProcessManagement?app.processName:null,uid,uid,
  29. gids,debugFlags,null);
  31. ......
  33. }catch(RuntimeExceptione){
  35. ......
  37. }
  38. }
  40. ......
  42. }
它调用了Process.start函数开始为应用程序创建新的进程，注意，它传入一个第一个参数为"android.app.ActivityThread"，这就是进程初始化时要加载的Java类了，把这个类加载到进程之后，就会把它里面的静态成员函数main作为进程的入口点，后面我们会看到。

Step 2. Process.start

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

view plain
  1. publicclassProcess{
  2. ......
  4. publicstaticfinalintstart(finalStringprocessClass,
  5. finalStringniceName,
  6. intuid,intgid,int[]gids,
  7. intdebugFlags,
  8. String[]zygoteArgs)
  9. {
  10. if(supportsProcesses()){
  11. try{
  12. returnstartViaZygote(processClass,niceName,uid,gid,gids,
  13. debugFlags,zygoteArgs);
  14. }catch(ZygoteStartFailedExex){
  15. ......
  16. }
  17. }else{
  18. ......
  20. return0;
  21. }
  22. }
  24. ......
  25. }
这里的supportsProcesses函数返回值为true，它是一个Native函数，实现在frameworks/base/core/jni/android_util_Process.cpp文件中：
view plain
  1. jbooleanandroid_os_Process_supportsProcesses(JNIEnv*env,jobjectclazz)
  2. {
  3. returnProcessState::self()->supportsProcesses();
  4. }

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

view plain
  1. boolProcessState::supportsProcesses()const
  2. {
  3. returnmDriverFD>=0;
  4. }
这里的mDriverFD是设备文件/dev/binder的打开描述符，如果成功打开了这个设备文件，那么它的值就会大于等于0，因此，它的返回值为true。

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

Step 3.Process.startViaZygote

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

view plain
  1. publicclassProcess{
  2. ......
  4. privatestaticintstartViaZygote(finalStringprocessClass,
  5. finalStringniceName,
  6. finalintuid,finalintgid,
  7. finalint[]gids,
  8. intdebugFlags,
  9. String[]extraArgs)
  10. throwsZygoteStartFailedEx{
  11. intpid;
  13. synchronized(Process.class){
  14. ArrayList<String>argsForZygote=newArrayList<String>();
  16. //--runtime-init,--setuid=,--setgid=,
  17. //and--setgroups=mustgofirst
  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. }
  34. //TODOoptionallyenabledebuger
  35. //argsForZygote.add("--enable-debugger");
  37. //--setgroupsisacomma-separatedlist
  38. if(gids!=null&&gids.length>0){
  39. StringBuildersb=newStringBuilder();
  40. sb.append("--setgroups=");
  42. intsz=gids.length;
  43. for(inti=0;i<sz;i++){
  44. if(i!=0){
  45. sb.append(',');
  46. }
  47. sb.append(gids[i]);
  48. }
  50. argsForZygote.add(sb.toString());
  51. }
  53. if(niceName!=null){
  54. argsForZygote.add("--nice-name="+niceName);
  55. }
  57. argsForZygote.add(processClass);
  59. if(extraArgs!=null){
  60. for(Stringarg:extraArgs){
  61. argsForZygote.add(arg);
  62. }
  63. }
  65. pid=zygoteSendArgsAndGetPid(argsForZygote);
  66. }
  67. }
  69. ......
  70. }
这个函数将创建进程的参数放到argsForZygote列表中去，如参数"--runtime-init"表示要为新创建的进程初始化运行时库，然后调用zygoteSendAndGetPid函数进一步操作。

Step 4. Process.zygoteSendAndGetPid

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

view plain
  1. publicclassProcess{
  2. ......
  4. privatestaticintzygoteSendArgsAndGetPid(ArrayList<String>args)
  5. throwsZygoteStartFailedEx{
  6. intpid;
  8. openZygoteSocketIfNeeded();
  10. try{
  11. /**
  12. *Seecom.android.internal.os.ZygoteInit.readArgumentList()
  13. *Presentlythewireformattothezygoteprocessis:
  14. *a)acountofarguments(argc,inessence)
  15. *b)anumberofnewline-separatedargumentstringsequaltocount
  16. *
  17. *Afterthezygoteprocessreadstheseitwillwritethepidof
  18. *thechildor-1onfailure.
  19. */
  21. sZygoteWriter.write(Integer.toString(args.size()));
  22. sZygoteWriter.newLine();
  24. intsz=args.size();
  25. for(inti=0;i<sz;i++){
  26. Stringarg=args.get(i);
  27. if(arg.indexOf('\n')>=0){
  28. thrownewZygoteStartFailedEx(
  29. "embeddednewlinesnotallowed");
  30. }
  31. sZygoteWriter.write(arg);
  32. sZygoteWriter.newLine();
  33. }
  35. sZygoteWriter.flush();
  37. //Shouldtherebeatimeoutonthis?
  38. pid=sZygoteInputStream.readInt();
  40. if(pid<0){
  41. thrownewZygoteStartFailedEx("fork()failed");
  42. }
  43. }catch(IOExceptionex){
  44. ......
  45. }
  47. returnpid;
  48. }
  50. ......
  51. }
这里的sZygoteWriter是一个Socket写入流，是由openZygoteSocketIfNeeded函数打开的：
view plain
  1. publicclassProcess{
  2. ......
  4. /**
  5. *TriestoopensockettoZygoteprocessifnotalreadyopen.If
  6. *alreadyopen,doesnothing.Mayblockandretry.
  7. */
  8. privatestaticvoidopenZygoteSocketIfNeeded()
  9. throwsZygoteStartFailedEx{
  11. intretryCount;
  13. if(sPreviousZygoteOpenFailed){
  14. /*
  15. *Ifwe'vefailedbefore,expectthatwe'llfailagainand
  16. *don'tpauseforretries.
  17. */
  18. retryCount=0;
  19. }else{
  20. retryCount=10;
  21. }
  23. /*
  24. *Seebug#811181:Sometimesruntimecanmakeitupbeforezygote.
  25. *Really,we'dliketodosomethingbettertoavoidthiscondition,
  26. *butfornowjustwaitabit...
  27. */
  28. for(intretry=0
  29. ;(sZygoteSocket==null)&&(retry<(retryCount+1))
  30. ;retry++){
  32. if(retry>0){
  33. try{
  34. Log.i("Zygote","Zygotenotupyet,sleeping...");
  35. Thread.sleep(ZYGOTE_RETRY_MILLIS);
  36. }catch(InterruptedExceptionex){
  37. //shouldneverhappen
  38. }
  39. }
  41. try{
  42. sZygoteSocket=newLocalSocket();
  43. sZygoteSocket.connect(newLocalSocketAddress(ZYGOTE_SOCKET,
  44. LocalSocketAddress.Namespace.RESERVED));
  46. sZygoteInputStream
  47. =newDataInputStream(sZygoteSocket.getInputStream());
  49. sZygoteWriter=
  50. newBufferedWriter(
  51. newOutputStreamWriter(
  52. sZygoteSocket.getOutputStream()),
  53. 256);
  55. Log.i("Zygote","Process:zygotesocketopened");
  57. sPreviousZygoteOpenFailed=false;
  58. break;
  59. }catch(IOExceptionex){
  60. ......
  61. }
  62. }
  64. ......
  65. }
  67. ......
  68. }
这个Socket由frameworks/base/core/java/com/android/internal/os/ZygoteInit.java文件中的ZygoteInit类在runSelectLoopMode函数侦听的。
Step 5.ZygoteInit.runSelectLoopMode
这个函数定义在frameworks/base/core/java/com/android/internal/os/ZygoteInit.java文件中：
view plain
  1. publicclassZygoteInit{
  2. ......
  4. /**
  5. *Runsthezygoteprocess'sselectloop.Acceptsnewconnectionsas
  6. *theyhappen,andreadscommandsfromconnectionsonespawn-request's
  7. *worthatatime.
  8. *
  9. *@throwsMethodAndArgsCallerinachildprocesswhenamain()should
  10. *beexecuted.
  11. */
  12. privatestaticvoidrunSelectLoopMode()throwsMethodAndArgsCaller{
  13. ArrayList<FileDescriptor>fds=newArrayList();
  14. ArrayList<ZygoteConnection>peers=newArrayList();
  15. FileDescriptor[]fdArray=newFileDescriptor[4];
  17. fds.add(sServerSocket.getFileDescriptor());
  18. peers.add(null);
  20. intloopCount=GC_LOOP_COUNT;
  21. while(true){
  22. intindex;
  23. /*
  24. *Callgc()beforeweblockinselect().
  25. *It'sworkthathastobedoneanyway,andit'sbetter
  26. *toavoidmakingeverychilddoit.Itwillalso
  27. *madvise()anyfreememoryasaside-effect.
  28. *
  29. *Don'tcalliteverytime,becausewalkingtheentire
  30. *heapisalotofoverheadtofreeafewhundredbytes.
  31. */
  32. if(loopCount<=0){
  33. gc();
  34. loopCount=GC_LOOP_COUNT;
  35. }else{
  36. loopCount--;
  37. }
  40. try{
  41. fdArray=fds.toArray(fdArray);
  42. index=selectReadable(fdArray);
  43. }catch(IOExceptionex){
  44. thrownewRuntimeException("Errorinselect()",ex);
  45. }
  47. if(index<0){
  48. thrownewRuntimeException("Errorinselect()");
  49. }elseif(index==0){
  50. ZygoteConnectionnewPeer=acceptCommandPeer();
  51. peers.add(newPeer);
  52. fds.add(newPeer.getFileDesciptor());
  53. }else{
  54. booleandone;
  55. done=peers.get(index).runOnce();
  57. if(done){
  58. peers.remove(index);
  59. fds.remove(index);
  60. }
  61. }
  62. }
  63. }
  65. ......
  66. }
当Step 4将数据通过Socket接口发送出去后，就会下面这个语句：
view plain
  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文件中：

view plain
  1. classZygoteConnection{
  2. ......
  4. booleanrunOnce()throwsZygoteInit.MethodAndArgsCaller{
  5. Stringargs[];
  6. ArgumentsparsedArgs=null;
  7. FileDescriptor[]descriptors;
  9. try{
  10. args=readArgumentList();
  11. descriptors=mSocket.getAncillaryFileDescriptors();
  12. }catch(IOExceptionex){
  13. ......
  14. returntrue;
  15. }
  17. ......
  19. /**thestderrofthemostrecentrequest,ifavail*/
  20. PrintStreamnewStderr=null;
  22. if(descriptors!=null&&descriptors.length>=3){
  23. newStderr=newPrintStream(
  24. newFileOutputStream(descriptors[2]));
  25. }
  27. intpid;
  29. try{
  30. parsedArgs=newArguments(args);
  32. applyUidSecurityPolicy(parsedArgs,peer);
  33. applyDebuggerSecurityPolicy(parsedArgs);
  34. applyRlimitSecurityPolicy(parsedArgs,peer);
  35. applyCapabilitiesSecurityPolicy(parsedArgs,peer);
  37. int[][]rlimits=null;
  39. if(parsedArgs.rlimits!=null){
  40. rlimits=parsedArgs.rlimits.toArray(intArray2d);
  41. }
  43. pid=Zygote.forkAndSpecialize(parsedArgs.uid,parsedArgs.gid,
  44. parsedArgs.gids,parsedArgs.debugFlags,rlimits);
  45. }catch(IllegalArgumentExceptionex){
  46. ......
  47. }catch(ZygoteSecurityExceptionex){
  48. ......
  49. }
  51. if(pid==0){
  52. //inchild
  53. handleChildProc(parsedArgs,descriptors,newStderr);
  54. //shouldneverhappen
  55. returntrue;
  56. }else{/*pid!=0*/
  57. //inparent...pidof<0meansfailure
  58. returnhandleParentProc(pid,descriptors,parsedArgs);
  59. }
  60. }
  62. ......
  63. }
真正创建进程的地方就是在这里了：
view plain
  1. pid=Zygote.forkAndSpecialize(parsedArgs.uid,parsedArgs.gid,
  2. parsedArgs.gids,parsedArgs.debugFlags,rlimits);
有Linux开发经验的读者很容易看懂这个函数调用，这个函数会创建一个进程，而且有两个返回值，一个是在当前进程中返回的，一个是在新创建的进程中返回，即在当前进程的子进程中返回，在当前进程中的返回值就是新创建的子进程的pid值，而在子进程中的返回值是0。因为我们只关心创建的新进程的情况，因此，我们沿着子进程的执行路径继续看下去：
view plain
  1. if(pid==0){
  2. //inchild
  3. handleChildProc(parsedArgs,descriptors,newStderr);
  4. //shouldneverhappen
  5. returntrue;
  6. }else{/*pid!=0*/
  7. ......
  8. }
这里就是调用handleChildProc函数了。

Step 7.ZygoteConnection.handleChildProc
这个函数定义在frameworks/base/core/java/com/android/internal/os/ZygoteConnection.java文件中：

view plain
  1. classZygoteConnection{
  2. ......
  4. privatevoidhandleChildProc(ArgumentsparsedArgs,
  5. FileDescriptor[]descriptors,PrintStreamnewStderr)
  6. throwsZygoteInit.MethodAndArgsCaller{
  7. ......
  9. if(parsedArgs.runtimeInit){
  10. RuntimeInit.zygoteInit(parsedArgs.remainingArgs);
  11. }else{
  12. ......
  13. }
  14. }
  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文件中：

view plain
  1. publicclassRuntimeInit{
  2. ......
  4. publicstaticfinalvoidzygoteInit(String[]argv)
  5. throwsZygoteInit.MethodAndArgsCaller{
  6. //TODO:Doingthishereworks,butitseemskindofarbitrary.Find
  7. //abetterplace.Thegoalistosetitupforapplications,butnot
  8. //toolslikeam.
  9. System.setOut(newAndroidPrintStream(Log.INFO,"System.out"));
  10. System.setErr(newAndroidPrintStream(Log.WARN,"System.err"));
  12. commonInit();
  13. zygoteInitNative();
  15. intcurArg=0;
  16. for(/*curArg*/;curArg<argv.length;curArg++){
  17. Stringarg=argv[curArg];
  19. if(arg.equals("--")){
  20. curArg++;
  21. break;
  22. }elseif(!arg.startsWith("--")){
  23. break;
  24. }elseif(arg.startsWith("--nice-name=")){
  25. StringniceName=arg.substring(arg.indexOf('=')+1);
  26. Process.setArgV0(niceName);
  27. }
  28. }
  30. if(curArg==argv.length){
  31. Slog.e(TAG,"MissingclassnameargumenttoRuntimeInit!");
  32. //lettheprocessexit
  33. return;
  34. }
  36. //Remainingargumentsarepassedtothestartclass'sstaticmain
  38. StringstartClass=argv[curArg++];
  39. String[]startArgs=newString[argv.length-curArg];
  41. System.arraycopy(argv,curArg,startArgs,0,startArgs.length);
  42. invokeStaticMain(startClass,startArgs);
  43. }
  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文件中：

view plain
  1. publicclassRuntimeInit{
  2. ......
  4. publicstaticfinalnativevoidzygoteInitNative();
  6. ......
  7. }
这里可以看出，函数zygoteInitNative是一个Native函数，实现在frameworks/base/core/jni/AndroidRuntime.cpp文件中：
view plain
  1. staticvoidcom_android_internal_os_RuntimeInit_zygoteInit(JNIEnv*env,jobjectclazz)
  2. {
  3. gCurRuntime->onZygoteInit();
  4. }

这里它调用了全局变量gCurRuntime的onZygoteInit函数，这个全局变量的定义在frameworks/base/core/jni/AndroidRuntime.cpp文件开头的地方：

view plain
  1. staticAndroidRuntime*gCurRuntime=NULL;
这里可以看出，它的类型为AndroidRuntime，它是在AndroidRuntime类的构造函数中初始化的，AndroidRuntime类的构造函数也是定义在frameworks/base/core/jni/AndroidRuntime.cpp文件中：
view plain
  1. AndroidRuntime::AndroidRuntime()
  2. {
  3. ......
  5. assert(gCurRuntime==NULL);//oneperprocess
  6. gCurRuntime=this;
  7. }
那么这个AndroidRuntime类的构造函数又是什么时候被调用的呢？AndroidRuntime类的声明在frameworks/base/include/android_runtime/AndroidRuntime.h文件中，如果我们打开这个文件会看到，它是一个虚拟类，也就是我们不能直接创建一个AndroidRuntime对象，只能用一个AndroidRuntime类的指针来指向它的某一个子类，这个子类就是AppRuntime了，它定义在frameworks/base/cmds/app_process/app_main.cpp文件中：
view plain
  1. intmain(intargc,constchar*constargv[])
  2. {
  3. ......
  5. AppRuntimeruntime;
  7. ......
  8. }
而AppRuntime类继续了AndroidRuntime类，它也是定义在frameworks/base/cmds/app_process/app_main.cpp文件中：
view plain
  1. classAppRuntime:publicAndroidRuntime
  2. {
  3. ......
  5. };
因此，在前面的com_android_internal_os_RuntimeInit_zygoteInit函数，实际是执行了AppRuntime类的onZygoteInit函数。

Step 10.AppRuntime.onZygoteInit
这个函数定义在frameworks/base/cmds/app_process/app_main.cpp文件中：

view plain
  1. classAppRuntime:publicAndroidRuntime
  2. {
  3. ......
  5. virtualvoidonZygoteInit()
  6. {
  7. sp<ProcessState>proc=ProcessState::self();
  8. if(proc->supportsProcesses()){
  9. LOGV("Appprocess:startingthreadpool.\n");
  10. proc->startThreadPool();
  11. }
  12. }
  14. ......
  15. };
这里它就是调用ProcessState::startThreadPool启动线程池了，这个线程池中的线程就是用来和Binder驱动程序进行交互的了。
Step 11.ProcessState.startThreadPool
这个函数定义在frameworks/base/libs/binder/ProcessState.cpp文件中：
view plain
  1. voidProcessState::startThreadPool()
  2. {
  3. AutoMutex_l(mLock);
  4. if(!mThreadPoolStarted){
  5. mThreadPoolStarted=true;
  6. spawnPooledThread(true);
  7. }
  8. }
ProcessState类是Binder进程间通信机制的一个基础组件，它的作用可以参考浅谈Android系统进程间通信（IPC）机制Binder中的Server和Client获得Service Manager接口之路、Android系统进程间通信（IPC）机制Binder中的Server启动过程源代码分析和Android系统进程间通信（IPC）机制Binder中的Client获得Server远程接口过程源代码分析这三篇文章。这里它调用spawnPooledThread函数进一步处理。

Step 12.ProcessState.spawnPooledThread

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

view plain
  1. voidProcessState::spawnPooledThread(boolisMain)
  2. {
  3. if(mThreadPoolStarted){
  4. int32_ts=android_atomic_add(1,&mThreadPoolSeq);
  5. charbuf[32];
  6. sprintf(buf,"BinderThread#%d",s);
  7. LOGV("Spawningnewpooledthread,name=%s\n",buf);
  8. sp<Thread>t=newPoolThread(isMain);
  9. t->run(buf);
  10. }
  11. }
这里它会创建一个PoolThread线程类，然后执行它的run函数，最终就会执行PoolThread类的threadLoop函数了。

Step 13.PoolThread.threadLoop

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

view plain
  1. classPoolThread:publicThread
  2. {
  3. public:
  4. PoolThread(boolisMain)
  5. :mIsMain(isMain)
  6. {
  7. }
  9. protected:
  10. virtualboolthreadLoop()
  11. {
  12. IPCThreadState::self()->joinThreadPool(mIsMain);
  13. returnfalse;
  14. }
  16. constboolmIsMain;
  17. };
这里它执行了IPCThreadState::joinThreadPool函数进一步处理。IPCThreadState也是Binder进程间通信机制的一个基础组件，它的作用可以参考浅谈Android系统进程间通信（IPC）机制Binder中的Server和Client获得Service Manager接口之路、Android系统进程间通信（IPC）机制Binder中的Server启动过程源代码分析和Android系统进程间通信（IPC）机制Binder中的Client获得Server远程接口过程源代码分析这三篇文章。

Step 14.IPCThreadState.joinThreadPool

这个函数定义在frameworks/base/libs/binder/IPCThreadState.cpp文件中：

view plain
  1. voidIPCThreadState::joinThreadPool(boolisMain)
  2. {
  3. ......
  5. mOut.writeInt32(isMain?BC_ENTER_LOOPER:BC_REGISTER_LOOPER);
  7. ......
  9. status_tresult;
  10. do{
  11. int32_tcmd;
  13. ......
  15. //nowgetthenextcommandtobeprocessed,waitingifnecessary
  16. result=talkWithDriver();
  17. if(result>=NO_ERROR){
  18. size_tIN=mIn.dataAvail();
  19. if(IN<sizeof(int32_t))continue;
  20. cmd=mIn.readInt32();
  21. ......
  23. result=executeCommand(cmd);
  24. }
  26. ......
  27. }while(result!=-ECONNREFUSED&&result!=-EBADF);
  29. ......
  31. mOut.writeInt32(BC_EXIT_LOOPER);
  32. talkWithDriver(false);
  33. }
这个函数首先告诉Binder驱动程序，这条线程要进入循环了：
view plain
  1. mOut.writeInt32(isMain?BC_ENTER_LOOPER:BC_REGISTER_LOOPER);
然后在中间的while循环中通过talkWithDriver不断与Binder驱动程序进行交互，以便获得Client端的进程间调用：
view plain
  1. result=talkWithDriver();
获得了Client端的进程间调用后，就调用excuteCommand函数来处理这个请求：
view plain
  1. result=executeCommand(cmd);
最后，线程退出时，也会告诉Binder驱动程序，它退出了，这样Binder驱动程序就不会再在Client端的进程间调用分发给它了：
view plain
  1. mOut.writeInt32(BC_EXIT_LOOPER);
  2. talkWithDriver(false);
我们再来看看talkWithDriver函数的实现。

Step 15. talkWithDriver

这个函数定义在frameworks/base/libs/binder/IPCThreadState.cpp文件中：

view plain
  1. status_tIPCThreadState::talkWithDriver(booldoReceive)
  2. {
  3. ......
  5. binder_write_readbwr;
  7. //Isthereadbufferempty?
  8. constboolneedRead=mIn.dataPosition()>=mIn.dataSize();
  10. //Wedon'twanttowriteanythingifwearestillreading
  11. //fromdataleftintheinputbufferandthecaller
  12. //hasrequestedtoreadthenextdata.
  13. constsize_toutAvail=(!doReceive||needRead)?mOut.dataSize():0;
  15. bwr.write_size=outAvail;
  16. bwr.write_buffer=(longunsignedint)mOut.data();
  18. //Thisiswhatwe'llread.
  19. if(doReceive&&needRead){
  20. bwr.read_size=mIn.dataCapacity();
  21. bwr.read_buffer=(longunsignedint)mIn.data();
  22. }else{
  23. bwr.read_size=0;
  24. }
  26. ......
  28. //Returnimmediatelyifthereisnothingtodo.
  29. if((bwr.write_size==0)&&(bwr.read_size==0))returnNO_ERROR;
  31. bwr.write_consumed=0;
  32. bwr.read_consumed=0;
  33. status_terr;
  34. do{
  35. ......
  36. #ifdefined(HAVE_ANDROID_OS)
  37. if(ioctl(mProcess->mDriverFD,BINDER_WRITE_READ,&bwr)>=0)
  38. err=NO_ERROR;
  39. else
  40. err=-errno;
  41. #else
  42. err=INVALID_OPERATION;
  43. #endif
  44. ......
  45. }
  46. }while(err==-EINTR);
  48. ....
  50. if(err>=NO_ERROR){
  51. if(bwr..write_consumed>0){
  52. if(bwr.write_consumed<(ssize_t)mOut.dataSize())
  53. mOut.remove(0,bwr.write_consumed);
  54. else
  55. mOut.setDataSize(0);
  56. }
  57. if(bwr.read_consumed>0){
  58. mIn.setDataSize(bwr.read_consumed);
  59. mIn.setDataPosition(0);
  60. }
  61. ......
  62. returnNO_ERROR;
  63. }
  65. returnerr;
  66. }
这个函数的具体作用可以参考Android系统进程间通信（IPC）机制Binder中的Server启动过程源代码分析一文，它只要就是通过ioctl文件操作函数来和Binder驱动程序交互的了：
view plain
  1. ioctl(mProcess->mDriverFD,BINDER_WRITE_READ,&bwr)
有了这个线程池之后，我们在开发Android应用程序的时候，当我们要和其它进程中进行通信时，只要定义自己的Binder对象，然后把这个Binder对象的远程接口通过其它途径传给其它进程后，其它进程就可以通过这个Binder对象的远程接口来调用我们的应用程序进程的函数了，它不像我们在C++层实现Binder进程间通信机制的Server时，必须要手动调用IPCThreadState.joinThreadPool函数来进入一个无限循环中与Binder驱动程序交互以便获得Client端的请求，这样就实现了我们在文章开头处说的Android应用程序进程天然地支持Binder进程间通信机制。

细心的读者可能会发现，从Step 1到Step 9，都是在Android应用程序框架层运行的，而从Step 10到Step 15，都是在Android系统运行时库层运行的，这两个层次中的Binder进程间通信机制的接口一个是用Java来实现的，而别一个是用C++来实现的，这两者是如何协作的呢？这就是通过JNI层来实现的了，具体可以参考Android系统进程间通信Binder机制在应用程序框架层的Java接口源代码分析一文。

回到Step 8中的RuntimeInit.zygoteInit函数中，在初始化完成Binder进程间通信机制的基础设施后，它接着就要进入进程的入口函数了。

Step 16.RuntimeInit.invokeStaticMain

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

view plain
  1. publicclassZygoteInit{
  2. ......
  4. staticvoidinvokeStaticMain(ClassLoaderloader,
  5. StringclassName,String[]argv)
  6. throwsZygoteInit.MethodAndArgsCaller{
  7. Class<?>cl;
  9. try{
  10. cl=loader.loadClass(className);
  11. }catch(ClassNotFoundExceptionex){
  12. ......
  13. }
  15. Methodm;
  16. try{
  17. m=cl.getMethod("main",newClass[]{String[].class});
  18. }catch(NoSuchMethodExceptionex){
  19. ......
  20. }catch(SecurityExceptionex){
  21. ......
  22. }
  24. intmodifiers=m.getModifiers();
  25. ......
  27. /*
  28. *ThisthrowgetscaughtinZygoteInit.main(),whichresponds
  29. *byinvokingtheexception'srun()method.Thisarrangement
  30. *clearsupallthestackframesthatwererequiredinsetting
  31. *uptheprocess.
  32. */
  33. thrownewZygoteInit.MethodAndArgsCaller(m,argv);
  34. }
  36. ......
  37. }
前面我们说过，这里传进来的参数className字符串值为"android.app.ActivityThread"，这里就通ClassLoader.loadClass函数将它加载到进程中：
view plain
  1. cl=loader.loadClass(className);
然后获得它的静态成员函数main：
view plain
  1. m=cl.getMethod("main",newClass[]{String[].class});
函数最后并没有直接调用这个静态成员函数main，而是通过抛出一个异常ZygoteInit.MethodAndArgsCaller，然后让ZygoteInit.main函数在捕获这个异常的时候再调用android.app.ActivityThread类的main函数。为什么要这样做呢？注释里面已经讲得很清楚了，它是为了清理堆栈的，这样就会让android.app.ActivityThread类的main函数觉得自己是进程的入口函数，而事实上，在执行android.app.ActivityThread类的main函数之前，已经做了大量的工作了。

我们看看ZygoteInit.main函数在捕获到这个异常的时候做了什么事：

view plain
  1. publicclassZygoteInit{
  2. ......
  4. publicstaticvoidmain(Stringargv[]){
  5. try{
  6. ......
  7. }catch(MethodAndArgsCallercaller){
  8. caller.run();
  9. }catch(RuntimeExceptionex){
  10. ......
  11. }
  12. }
  14. ......
  15. }
它执行MethodAndArgsCaller的run函数：
view plain
  1. publicclassZygoteInit{
  2. ......
  4. publicstaticclassMethodAndArgsCallerextendsException
  5. implementsRunnable{
  6. /**methodtocall*/
  7. privatefinalMethodmMethod;
  9. /**argumentarray*/
  10. privatefinalString[]mArgs;
  12. publicMethodAndArgsCaller(Methodmethod,String[]args){
  13. mMethod=method;
  14. mArgs=args;
  15. }
  17. publicvoidrun(){
  18. try{
  19. mMethod.invoke(null,newObject[]{mArgs});
  20. }catch(IllegalAccessExceptionex){
  21. ......
  22. }catch(InvocationTargetExceptionex){
  23. ......
  24. }
  25. }
  26. }
  28. ......
  29. }
这里的成员变量mMethod和mArgs都是在前面构造异常对象时传进来的，这里的mMethod就对应android.app.ActivityThread类的main函数了，于是最后就通过下面语句执行这个函数：
view plain
  1. mMethod.invoke(null,newObject[]{mArgs});
这样，android.app.ActivityThread类的main函数就被执行了。

Step 17.ActivityThread.main

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

view plain
  1. publicfinalclassActivityThread{
  2. ......
  4. publicstaticfinalvoidmain(String[]args){
  5. SamplingProfilerIntegration.start();
  7. Process.setArgV0("<pre-initialized>");
  9. Looper.prepareMainLooper();
  10. if(sMainThreadHandler==null){
  11. sMainThreadHandler=newHandler();
  12. }
  14. ActivityThreadthread=newActivityThread();
  15. thread.attach(false);
  17. if(false){
  18. Looper.myLooper().setMessageLogging(new
  19. LogPrinter(Log.DEBUG,"ActivityThread"));
  20. }
  21. Looper.loop();
  23. if(Process.supportsProcesses()){
  24. thrownewRuntimeException("Mainthreadloopunexpectedlyexited");
  25. }
  27. thread.detach();
  28. Stringname=(thread.mInitialApplication!=null)
  29. ?thread.mInitialApplication.getPackageName()
  30. :"<unknown>";
  31. Slog.i(TAG,"Mainthreadof"+name+"isnowexiting");
  32. }
  34. ......
  35. }
从这里我们可以看出，这个函数首先会在进程中创建一个ActivityThread对象：
view plain
  1. ActivityThreadthread=newActivityThread();
然后进入消息循环中：
view plain
  1. Looper.loop();
这样，我们以后就可以在这个进程中启动Activity或者Service了。

至此，Android应用程序进程启动过程的源代码就分析完成了，它除了指定新的进程的入口函数是ActivityThread的main函数之外，还为进程内的Binder对象提供了Binder进程间通信机制的基础设施，由此可见，Binder进程间通信机制在Android系统中是何等的重要，而且是无处不在，想进一步学习Android系统的Binder进程间通信机制，请参考Android进程间通信（IPC）机制Binder简要介绍和学习计划一文。


wapysun
关注
Android应用程序进程启动过程的源代码解析
CodeJolt的博客
10-16 107
了解这些过程对于开发高质量的Android应用程序至关重要，因为它涉及到应用程序的初始化、资源加载和主活动的启动。在上述示例中，我们创建了一个Intent对象，指定了要启动的主活动（MainActivity），并添加了FLAG_ACTIVITY_NEW_TASK标志，以确保在新的任务栈中启动活动。在上述示例中，我们创建了一个Intent对象，指定了要启动的主活动（MainActivity），并添加了FLAG_ACTIVITY_NEW_TASK标志，以确保在新的任务栈中启动活动。
Frida不能和Magisk Hide一起使用
我的博客
06-21 4402
现象 今天结合kali使用Frida的过程中，发现Frida不能和Magisk Hide一起使用, 出现 frida.NotSupportedError: unable to access zygote64 while preparing for app launch; try disabling Magisk Hide in case it is active 的报错。 解决 需要在手机关掉Magisk Hide，路径(Magisk软件的Magisk Manager > Setting
Android 逆向之脱壳实战篇
Android技术之家
06-19 1022
大家好，我叫 Jack Darren，目前主要负责国内游戏发行 Android SDK 开发作者：37手游安卓团队链接：https://juejin.cn/post/7245854874196475963写这篇文章的背景 自从上次 Android 逆向入门保姆级教程(https://juejin.cn/post/7216968724938195001) 发布之后，便冲上了掘金 Android 热榜...
Ubuntu无法启动~错误：init:failed to spawn..解决方法
热门推荐
BenChang的专栏
11-04 1万+
今天上午做某实验的时候将/bin/sh的链接改
android byte转string_【Android 原创】从OWASP CrackMe学Android逆向(一)
weixin_39619481的博客
11-24 333
作者论坛账号：Se8s0n准备环境、工具Pixel(Magisk+Xposed/EdXposed)这里要安利一下Magisk，它现在有个超强的Magisk Hide功能，能隐藏root状态，不过我还没研究过它的原理，如果后面有机会的话会稍微整理一下的。UnCrackable-Level1进入到存有UnCrackable的文件目录下，adb install UnCrackable-Leve...
Android 64位机器system app兼容32位apk问题分析(共享system uid )
lb5761311的专栏
12-02 4655
rk3399 是一款基于arm64的机器，我们这边一款产品是基于rk3399 Android 7.1版本的开发，我们的 vtest.apk包含多个so，在正常userdebug模式下不会出现兼容性问题，如果切换到user版本就会出现概率性崩溃的问题。并且崩溃不是vtest.apk而且其他system apk 比如StressTest、 keychain、exchange等apk 概率性崩溃。 首...
Android应用程序进程启动过程的源代码分析.pdf
07-13
Android 应用程序进程启动过程的源代码分析 Android 应用程序进程启动过程是 Android 应用程序框架层创建的应用程序进程的入口函数 ActivityThread.main 在进程的初始化过程中实现的两个特点的分析。这些特点是...
Android应用程序启动过程源代码分析
03-04
在Android系统中，应用程序是由Activity组成的，因此，应用程序的启动过程实际上就是应用程序中的默认Activity的启动过程，本文将详细分析应用程序框架层的源代码，了解Android应用程序的启动过程。在上一篇文章...
Android启动过程（一）
万子的博客
09-03 898
安卓架构图 （转自：https://www.jianshu.com/p/657336b545bd） loader>kernel>native>framework>app 作为安卓的第一个进程init（pid =1），init将通过解析init.rc来陆续启动其他关键服务进程（ServiceManager,Zygote和SystemServer） 如果你本地看不了源码的话，可以通过在线查看源码（https://www.androidos.net.cn/android/5
Android源码阅读---zygote(app_process)进程
helloWen
03-20 2150
Android源码阅读—zygote(app_process)进程 文章目录Android源码阅读---zygote(app_process)进程1. app_processpe的启动2. main函数流程3. 创建java运行环境4. ZygoteInit类主函数4.1 registerZygoteSocket4.2 preload4.3 startSystemServer4.3 runSele...
Android P 系统启动-Zygote启动篇
liondom的博客
03-24 513
概述： service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server class main priority -20 user root group root readproc reserved_disk socket zygote...
解决Failed with error: unable to access 'https://git.coding.net/chenmi1234/lianpos.git/': Couldn't res...
weixin_30408675的博客
01-02 1730
代码改变世界 github push 出现问题 Failed with error: unable to access 'https://git.coding.net/chenmi1234/lianpos.git/': Couldn't resolve host 'git.coding.net' 右键工程文件，点Git Base Here，弹出页面输入下面代码 git co...
Failed to mount emulated storage机器没法启动问题查找
oman111的专栏
04-11 5325
错误日志： E/cutils  ( 1180): Not a directory: /storage/sdcard0 W/Zygote  ( 1180): Failed to mount emulated storage: 22 E/Zygote  ( 1180): Cannot continue without emulated storage F/art
Android Framework学习(二)之Zygote进程启动解析
一个码农的博客
04-30 1881
上篇博客，我们学习了init进程的相关知识，本篇博客我们一次来学习zygote进程的相关知识。Zygote简介在Android系统中，JavaVM(Java虚拟机)、应用程序进程以及运行系统的关键服务的SystemServer进程都是由Zygote进程来创建的，我们也将它称为孵化器。它通过fock(复制进程)的形式来创建应用程序进程和SystemServer进程，由于Zygote进程在启动时会创建J
iOS开发之UICollectionView为什么需要配合UICollectionViewFlowLayout使用
qq_37203361的博客
08-20 339
本质上只是一个容器，用来展示一系列的 cell（单元格）。 它本身 不关心 cell 的摆放方式，只负责：Cell 的复用（避免性能浪费）Cell 的增删改查滚动与事件处理👉 那么 Cell 怎么排版？Cell 大小是多少？ 行间距、列间距、滚动方向是什么？ 这些都不是 的工作，而是交给 布局对象（Layout object）。苹果采用了 策略模式（Strategy Pattern）： 负责数据展示和交互。 负责计算布局。这样 就可以灵活切换布局策略，而不用修改控件本身。例如：想要网格布局，用 想要环
Flutter上手记：为什么我的按钮能同时在iOS和Android上跳舞？[特殊字符][特殊字符]
jiushiapwojdap的博客
08-22 620
Flutter不是银弹！碰到超复杂平台特性（比如ARCore深度图），可能还得写原生。但它把跨平台的UI一致性和开发速度做到了极致——这对创业公司/独立开发者简直是核武器！💣还记得上次我同时改iOS和Android的登录页吗？15分钟！同事端着咖啡过来时，我已经在刷推特了… 😎 这感觉——爽到飞起！“所以还在等啥？赶紧让你的按钮也跳支舞！” 💃🕺彩蛋：Flutter连桌面端（Windows/macOS/Linux）和嵌入式设备都能跑… 谷歌这是要统一宇宙？？（手动狗头）🐶。
第3课：Flutter基础组件
最新发布
lpfasd123的博客
08-22 709
Widget：Flutter应用的基本构建块声明式UI：通过描述UI的最终状态来构建界面不可变性：Widget是不可变的，一旦创建就不能修改组合性：通过组合简单的Widget来创建复杂的UI不可变性：Widget创建后不可修改，通过重建来更新UI组合性：通过组合简单Widget创建复杂界面声明式：描述UI的最终状态，而非如何构建。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值