原文地址：http://blog.csdn.net/luoshengyang/article/details/6747696

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

[java] view plain copy

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

[java] view plain copy

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

[cpp] view plain copy

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

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

[cpp] view plain copy

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

[java] view plain copy

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

[java] view plain copy

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函数打开的：

[java] view plain copy

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

[java] view plain copy

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接口发送出去后，就会下面这个语句：

[java] view plain copy

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

[java] view plain copy

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. }

真正创建进程的地方就是在这里了：

[java] view plain copy

1. pid=Zygote.forkAndSpecialize(parsedArgs.uid,parsedArgs.gid,
2. parsedArgs.gids,parsedArgs.debugFlags,rlimits);

有Linux开发经验的读者很容易看懂这个函数调用，这个函数会创建一个进程，而且有两个返回值，一个是在当前进程中返回的，一个是在新创建的进程中返回，即在当前进程的子进程中返回，在当前进程中的返回值就是新创建的子进程的pid值，而在子进程中的返回值是0。因为我们只关心创建的新进程的情况，因此，我们沿着子进程的执行路径继续看下去：

[java] view plain copy

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

[java] view plain copy

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

[java] view plain copy

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

[java] view plain copy

1. publicclassRuntimeInit{
2. ......
4. publicstaticfinalnativevoidzygoteInitNative();
6. ......
7. }

这里可以看出，函数zygoteInitNative是一个Native函数，实现在frameworks/base/core/jni/AndroidRuntime.cpp文件中：

[cpp] view plain copy

1. staticvoidcom_android_internal_os_RuntimeInit_zygoteInit(JNIEnv*env,jobjectclazz)
2. {
3. gCurRuntime->onZygoteInit();
4. }

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

[cpp] view plain copy

1. staticAndroidRuntime*gCurRuntime=NULL;

这里可以看出，它的类型为AndroidRuntime，它是在AndroidRuntime类的构造函数中初始化的，AndroidRuntime类的构造函数也是定义在frameworks/base/core/jni/AndroidRuntime.cpp文件中：

[cpp] view plain copy

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

[cpp] view plain copy

1. intmain(intargc,constchar*constargv[])
2. {
3. ......
5. AppRuntimeruntime;
7. ......
8. }

而AppRuntime类继续了AndroidRuntime类，它也是定义在frameworks/base/cmds/app_process/app_main.cpp文件中：

[cpp] view plain copy

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

[cpp] view plain copy

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

[cpp] view plain copy

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

[cpp] view plain copy

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

[cpp] view plain copy

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

[cpp] view plain copy

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驱动程序，这条线程要进入循环了：

[cpp] view plain copy

1. mOut.writeInt32(isMain?BC_ENTER_LOOPER:BC_REGISTER_LOOPER);

然后在中间的while循环中通过talkWithDriver不断与Binder驱动程序进行交互，以便获得Client端的进程间调用：

[cpp] view plain copy

1. result=talkWithDriver();

获得了Client端的进程间调用后，就调用excuteCommand函数来处理这个请求：

[cpp] view plain copy

1. result=executeCommand(cmd);

最后，线程退出时，也会告诉Binder驱动程序，它退出了，这样Binder驱动程序就不会再在Client端的进程间调用分发给它了：

[cpp] view plain copy

1. mOut.writeInt32(BC_EXIT_LOOPER);
2. talkWithDriver(false);

我们再来看看talkWithDriver函数的实现。

Step 15. talkWithDriver

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

[cpp] view plain copy

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驱动程序交互的了：

[cpp] view plain copy

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

[java] view plain copy

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函数将它加载到进程中：

[java] view plain copy

1. cl=loader.loadClass(className);

然后获得它的静态成员函数main：

[java] view plain copy

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函数在捕获到这个异常的时候做了什么事：

[java] view plain copy

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函数：

[java] view plain copy

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函数了，于是最后就通过下面语句执行这个函数：

[java] view plain copy

1. mMethod.invoke(null,newObject[]{mArgs});

这样，android.app.ActivityThread类的main函数就被执行了。

Step 17.ActivityThread.main

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

[java] view plain copy

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对象：

[java] view plain copy

1. ActivityThreadthread=newActivityThread();

然后进入消息循环中：

[java] view plain copy

1. Looper.loop();

这样，我们以后就可以在这个进程中启动Activity或者Service了。

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

更多相关文章

1. 箭头函数的基础使用
2. NPM 和webpack 的基础使用
3. Python技巧匿名函数、回调函数和高阶函数
4. 【阿里云镜像】使用阿里巴巴DNS镜像源——DNS配置教程
5. Android开机启动流程初探
6. Android系统中的广播（Broadcast）机制注册注销发送原理总结
7. Android(安卓)解决65535的限制（官网推荐方法）
8. Android中Message机制的灵活应用（一）
9. Android中通过typeface设置字体

随机推荐

1. RadioButton修改标志图片
2. 样式和主题-style&them
3. Android下单元测试
4. 最近总结的android疑惑
5. Android下修改ImageButton样式
6. Android(安卓)自定义搜索Searchable
7. 解决Could not find manifest-merger.jar
8. Android(安卓)Selector 与 Shape 基本用
9. 如何进行Android单元测试
10. Android：控件的隐藏显示失效了