Android FrameWork--SytemServer进程fork

1、Linux的fork

在Linux平台我们可以通过fork系统调用来创建一个新的进程，这个新的进程将会拥有原始进程的一份副本，包括代码、数据、内存等等。唯一的区别是新的进程拥有一个新的ID，使得它成为一个独立的进程，运行自己的代码。
fork()系统调用会返回两次，在原始进程中会返回进程ID，在新的进程中会返回0。两个进程可以执行相同的任务，也可以按照需要执行不同的代码。
fork的例子

#include <stdio.h>

#include <unistd.h>

int main(){

  printf("main start \n");

  int result = fork();

  pid_t pid = getpid();

  printf("pid is %d and result is %d\n",pid,result );

  return 0;

}

main start 
pid is 11647 and result is 11648
pid is 11648 and result is 0

我们看到main start只打印了一次，子进程从fork之后开始分叉执行。
第二行当前pid是11647 ，fork的结果是11648，表示当前在父进程执行
第三行当前pid是11648，恰好是父进程fork返回的进程ID,result的结果是0,也说明了本次的打印是在子进程中执行的。

2、SystemServer进程的fork

接着分析上次的ZygoteInit的源码。
frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

  if (startSystemServer) {
                Runnable r = forkSystemServer(abiList, socketName, zygoteServer);
                // {@code r == null} in the parent (zygote) process, and {@code r != null} in the
                // child (system_server) process.
              //如果是在system_server进程中执行，则返回Runnable ，并执行r.run函数
                if (r != null) {
                    r.run();
                    return;
                }
            }

    /**
     * Prepare the arguments and forks for the system server process.
     *
     * Returns an {@code Runnable} that provides an entrypoint into system_server code in the
     * child process, and {@code null} in the parent.
     */
private static Runnable forkSystemServer(String abiList, String socketName,
            ZygoteServer zygoteServer) {
       int pid;

        try {
            parsedArgs = new ZygoteConnection.Arguments(args);
            ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
            ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);

            /* Request to fork the system server process */
            //在这里请求fork  system server  进程
            pid = Zygote.forkSystemServer(
                    parsedArgs.uid, parsedArgs.gid,
                    parsedArgs.gids,
                    parsedArgs.debugFlags,
                    null,
                    parsedArgs.permittedCapabilities,
                    parsedArgs.effectiveCapabilities);
        } catch (IllegalArgumentException ex) {
            throw new RuntimeException(ex);
        }
        
        /* For child process */
      //如果pid为0，说明是在子进程中执行，因此关掉zygote进程继承下来的Socket
        if (pid == 0) {
            if (hasSecondZygote(abiList)) {
                waitForSecondaryZygote(socketName);
            }

            zygoteServer.closeServerSocket();
            return handleSystemServerProcess(parsedArgs);
        }

调用Zygote类的forkSystemServe函数请求fork子进程，如果pid为0，说明是在子进程中执行，因此关掉zygote进程继承下来的Socket。继续看forkSystemServer的代码。

    public static int forkSystemServer(int uid, int gid, int[] gids, int debugFlags,
            int[][] rlimits, long permittedCapabilities, long effectiveCapabilities) {
       ......
        int pid = nativeForkSystemServer(
                uid, gid, gids, debugFlags, rlimits, permittedCapabilities, effectiveCapabilities);
        .......
        return pid;
    }

  native private static int nativeForkSystemServer(int uid, int gid, int[] gids, int debugFlags,
           int[][] rlimits, long permittedCapabilities, long effectiveCapabilities);

在forkSystemServer函数中又调用了nativeForkSystemServer方法，这里要通过JNI调用Native函数
frameworks/base/core/jni/com_android_internal_os_Zygote.cpp
jint com_android_internal_os_Zygote_nativeForkSystemServer
ForkAndSpecializeCommon

static jint com_android_internal_os_Zygote_nativeForkSystemServer(
        JNIEnv* env, jclass, uid_t uid, gid_t gid, jintArray gids,
        jint debug_flags, jobjectArray rlimits, jlong permittedCapabilities,
        jlong effectiveCapabilities) {
  pid_t pid = ForkAndSpecializeCommon(env, uid, gid, gids,
                                      debug_flags, rlimits,
                                      permittedCapabilities, effectiveCapabilities,
                                      MOUNT_EXTERNAL_DEFAULT, NULL, NULL, true, NULL,
                                      NULL, NULL, NULL);
  if (pid > 0) {
    .....
  }
  return pid;
}

// Utility routine to fork zygote and specialize the child process.
static pid_t ForkAndSpecializeCommon(JNIEnv* env, uid_t uid, gid_t gid, jintArray javaGids,
                                     jint debug_flags, jobjectArray javaRlimits,
                                     jlong permittedCapabilities, jlong effectiveCapabilities,
                                     jint mount_external,
                                     jstring java_se_info, jstring java_se_name,
                                     bool is_system_server, jintArray fdsToClose,
                                     jintArray fdsToIgnore,
                                     jstring instructionSet, jstring dataDir) {
 ...........

  pid_t pid = fork();
.....
}

在ForkAndSpecializeCommon函数中我们看到了fork()的系统调用，这样system server进程就会被fork出来了。
而在最开始的代码我们看到最终调用forkSystemServer之后返回了一个Runnable r对象。

      Runnable r = forkSystemServer(abiList, socketName, zygoteServer);
          // {@code r == null} in the parent (zygote) process, and {@code r != null} in the
                // child (system_server) process.
              //如果是在system_server进程中执行，则返回Runnable ，并执行r.run函数
                if (r != null) {
                    r.run();
                    return;
                }

如果是在system_server进程中执行的话会返回一个Runnable r对象，并执行r.run()函数，也就是之后system_server进程的执行主要流程就在Runnable 的run函数中。

最后

如果想要成为架构师或想突破20~30K薪资范畴，那就不要局限在编码，业务，要会选型、扩展，提升编程思维。此外，良好的职业规划也很重要，学习的习惯很重要，但是最重要的还是要能持之以恒，任何不能坚持落实的计划都是空谈。

如果你没有方向，这里给大家分享一套由阿里高级架构师编写的《Android八大模块进阶笔记》，帮大家将杂乱、零散、碎片化的知识进行体系化的整理，让大家系统而高效地掌握Android开发的各个知识点。

相对于我们平时看的碎片化内容，这份笔记的知识点更系统化，更容易理解和记忆，是严格按照知识体系编排的。

全套视频资料：

一、面试合集

二、源码解析合集

三、开源框架合集

欢迎大家一键三连支持，若需要文中资料，直接扫描文末CSDN官方认证微信卡片免费领取↓↓↓