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

        
                
  1. publicclassZygoteInit{
    2.             
  2. ......
    3.             
    4.             
  4. privatestaticbooleanstartSystemServer()
    5.             
  5. throwsMethodAndArgsCaller,RuntimeException{
    6.             
  6. /*Hardcodedcommandlinetostartthesystemserver*/
    7.             
  7. Stringargs[]={
    8.             
  8. "--setuid=1000",
    9.             
  9. "--setgid=1000",
    10.             
  10. "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,3001,3002,3003",
    11.             
  11. "--capabilities=130104352,130104352",
    12.             
  12. "--runtime-init",
    13.             
  13. "--nice-name=system_server",
    14.             
  14. "com.android.server.SystemServer",
    15.             
  15. };
    16.             
  16. ZygoteConnection.ArgumentsparsedArgs=null;
    17.             
    18.             
  18. intpid;
    19.             
    20.             
  20. try{
    21.             
  21. parsedArgs=newZygoteConnection.Arguments(args);
    22.             
    23.             
  23. ......
    24.             
    25.             
  25. /*Requesttoforkthesystemserverprocess*/
    26.             
  26. pid=Zygote.forkSystemServer(
    27.             
  27. parsedArgs.uid,parsedArgs.gid,
    28.             
  28. parsedArgs.gids,debugFlags,null,
    29.             
  29. parsedArgs.permittedCapabilities,
    30.             
  30. parsedArgs.effectiveCapabilities);
    31.             
  31. }catch(IllegalArgumentExceptionex){
    32.             
  32. ......
    33.             
  33. }
    34.             
    35.             
  35. /*Forchildprocess*/
    36.             
  36. if(pid==0){
    37.             
  37. handleSystemServerProcess(parsedArgs);
    38.             
  38. }
    39.             
    40.             
  40. returntrue;
    41.             
  41. }
    42.             
    43.             
  43. ......
    44.             
  44. }
    45.

这里我们可以看到，Zygote进程通过Zygote.forkSystemServer函数来创建一个新的进程来启动SystemServer组件，返回值pid等0的地方就是新的进程要执行的路径，即新创建的进程会执行handleSystemServerProcess函数。

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

        
                
  1. 这里我们可以看到，Zygote进程通过Zygote.forkSystemServer函数来创建一个新的进程来启动SystemServer组件，返回值pid等0的地方就是新的进程要执行的路径，即新创建的进程会执行handleSystemServerProcess函数。
    2.             
  2. Step6.ZygoteInit.handleSystemServerProcess
    3.             
  3. 这个函数定义在frameworks/base/core/java/com/android/internal/os/ZygoteInit.java文件中：
    4.

由于由Zygote进程创建的子进程会继承Zygote进程在前面Step 4中创建的Socket文件描述符，而这里的子进程又不会用到它，因此，这里就调用closeServerSocket函数来关闭它。这个函数接着调用RuntimeInit.zygoteInit函数来进一步执行启动SystemServer组件的操作。

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

        
                
  1. publicclassRuntimeInit{
    2.             
  2. ......
    3.             
    4.             
  4. publicstaticfinalvoidzygoteInit(String[]argv)
    5.             
  5. throwsZygoteInit.MethodAndArgsCaller{
    6.             
  6. ......
    7.             
    8.             
  8. zygoteInitNative();
    9.             
    10.             
  10. ......
    11.             
    12.             
    13.             
  13. //Remainingargumentsarepassedtothestartclass'sstaticmain
    14.             
    15.             
  15. StringstartClass=argv[curArg++];
    16.             
  16. String[]startArgs=newString[argv.length-curArg];
    17.             
    18.             
  18. System.arraycopy(argv,curArg,startArgs,0,startArgs.length);
    19.             
  19. invokeStaticMain(startClass,startArgs);
    20.             
  20. }
    21.             
    22.             
  22. ......
    23.             
  23. }
    24.

这个函数会执行两个操作，一个是调用zygoteInitNative函数来执行一个Binder进程间通信机制的初始化工作，这个工作完成之后，这个进程中的Binder对象就可以方便地进行进程间通信了，另一个是调用上面Step 5传进来的com.android.server.SystemServer类的main函数。

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

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

这里可以看出，函数zygoteInitNative是一个Native函数，实现在frameworks/base/core/jni/AndroidRuntime.cpp文件中，这里我们就不再细看了，具体可以参考Android应用程序进程启动过程的源代码分析一文的Step 9，完成这一步后，这个进程的Binder进程间通信机制基础设施就准备好了。

回到Step 7中的RuntimeInit.zygoteInitNative函数，下一步它就要执行com.android.server.SystemServer类的main函数了。

Step 9.SystemServer.main
这个函数定义在frameworks/base/services/java/com/android/server/SystemServer.java文件中：

        
                
  1. publicclassSystemServer
    2.             
  2. {
    3.             
  3. ......
    4.             
    5.             
  5. nativepublicstaticvoidinit1(String[]args);
    6.             
    7.             
  7. ......
    8.             
    9.             
  9. publicstaticvoidmain(String[]args){
    10.             
  10. ......
    11.             
    12.             
  12. init1(args);
    13.             
    14.             
  14. ......
    15.             
  15. }
    16.             
    17.             
  17. publicstaticfinalvoidinit2(){
    18.             
  18. Slog.i(TAG,"EnteredtheAndroidsystemserver!");
    19.             
  19. Threadthr=newServerThread();
    20.             
  20. thr.setName("android.server.ServerThread");
    21.             
  21. thr.start();
    22.             
  22. }
    23.             
    24.             
  24. ......
    25.             
  25. }
    26.

这里的main函数首先会执行JNI方法init1，然后init1会调用这里的init2函数，在init2函数里面，会创建一个ServerThread线程对象来执行一些系统关键服务的启动操作，例如我们在前面两篇文章Android应用程序安装过程源代码分析和Android系统默认Home应用程序（Launcher）的启动过程源代码分析中提到的PackageManagerService和ActivityManagerService。
这一步的具体执行过程可以参考Android应用程序安装过程源代码分析一文，这里就不再详述了。

这里执行完成后，层层返回，最后回到上面的Step 3中的ZygoteInit.main函数中，接下来它就要调用runSelectLoopMode函数进入一个无限循环在前面Step 4中创建的socket接口上等待ActivityManagerService请求创建新的应用程序进程了。

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

        
                
  1. publicclassZygoteInit{
    2.             
  2. ......
    3.             
    4.             
  4. privatestaticvoidrunSelectLoopMode()throwsMethodAndArgsCaller{
    5.             
  5. ArrayList<FileDescriptor>fds=newArrayList();
    6.             
  6. ArrayList<ZygoteConnection>peers=newArrayList();
    7.             
  7. FileDescriptor[]fdArray=newFileDescriptor[4];
    8.             
    9.             
  9. fds.add(sServerSocket.getFileDescriptor());
    10.             
  10. peers.add(null);
    11.             
    12.             
  12. intloopCount=GC_LOOP_COUNT;
    13.             
  13. while(true){
    14.             
  14. intindex;
    15.             
    16.             
  16. ......
    17.             
    18.             
    19.             
  19. try{
    20.             
  20. fdArray=fds.toArray(fdArray);
    21.             
  21. index=selectReadable(fdArray);
    22.             
  22. }catch(IOExceptionex){
    23.             
  23. thrownewRuntimeException("Errorinselect()",ex);
    24.             
  24. }
    25.             
    26.             
  26. if(index<0){
    27.             
  27. thrownewRuntimeException("Errorinselect()");
    28.             
  28. }elseif(index==0){
    29.             
  29. ZygoteConnectionnewPeer=acceptCommandPeer();
    30.             
  30. peers.add(newPeer);
    31.             
  31. fds.add(newPeer.getFileDesciptor());
    32.             
  32. }else{
    33.             
  33. booleandone;
    34.             
  34. done=peers.get(index).runOnce();
    35.             
    36.             
  36. if(done){
    37.             
  37. peers.remove(index);
    38.             
  38. fds.remove(index);
    39.             
  39. }
    40.             
  40. }
    41.             
  41. }
    42.             
  42. }
    43.             
    44.             
  44. ......
    45.             
  45. }
    46.

这个函数我们已经在Android应用程序进程启动过程的源代码分析一文的Step 5中分析过了，这就是在等待ActivityManagerService来连接这个Socket，然后调用ZygoteConnection.runOnce函数来创建新的应用程序，有兴趣的读者可以参考Android应用程序进程启动过程的源代码分析这篇文章，这里就不再详述了。

这样，Zygote进程就启动完成了，学习到这里，我们终于都对Android系统中的进程有了一个深刻的认识了，这里总结一下：

1. 系统启动时init进程会创建Zygote进程，Zygote进程负责后续Android应用程序框架层的其它进程的创建和启动工作。

2. Zygote进程会首先创建一个SystemServer进程，SystemServer进程负责启动系统的关键服务，如包管理服务PackageManagerService和应用程序组件管理服务ActivityManagerService。

3. 当我们需要启动一个Android应用程序时，ActivityManagerService会通过Socket进程间通信机制，通知Zygote进程为这个应用程序创建一个新的进程。

更多相关文章

  1. C语言函数以及函数的使用
  2. [Android Studio] Android Studio如何提示函数用法
  3. Android 驱动之旅 第四章：在Android 系统中编写JNI 方法在应用程
  4. Android 进程和线程模型 .
  5. Android Wear应用程序开发的简要说明，对每个初学者和中级android
  6. （一）Android应用程序及组件简介
  7. Android应用程序资源管理器（Asset Manager）的创建过程分析
  8. 进程和线程模型（android）

随机推荐

  1. Android的系统的Binder机制（一）
  2. 构建Android开发环境
  3. 在Android库中不能使用switch-case语句访
  4. Android SVG矢量资源的使用方法
  5. Android(安卓)Studio
  6. Android属性动画优化（更高效的使用属性动
  7. Android精华汇总
  8. Android分区查看
  9. Android(安卓)Wallpaper分析
  10. 使用ProgressBar显示进度条