Android系统启动Zygote进程(api 29)

作者: 有没有口罩给我一个 | 来源:发表于2020-07-11 23:44 被阅读0次

dvm，app进程，linux进程三者关系？

dvm即：dalivk ，指的是google基于jvm重新定义的虚拟机。每一个 Android 应用程序都在它自己的进程中运行，都拥有一个独立的 Dalvik 虚拟机实例和自己的独立数据空间。而每一个 dvm 都是由一个叫zygote进程fork出来拥有和zygote进程完全一致的数据空间包括程序计数器，而zygote则由 Linux 中的init进程创建的，所以说可以认为是同一个概念。

Linux fork的原理

上面我提到应用进程和系统进程都是由Zygote继承fork出来，那在开始之前我们先来简单了解一下Linux API fork的工作原理，看看下面的fork的代码：

// JNI
extern "C" JNIEXPORT jint JNICALLJava_com_wfy_myapplication_ForkProcessTestMainActivity_fork(JNIEnv *env, jobject thiz) {
    LOGE("%s%d", "当前进程 native ID= ", getpid());
    LOGE("%s%d", "当前进程的父进程 native ID= ", getppid());
    int pid = fork();  
    if (pid == -1) return -1;//失败
    if (pid) {
        LOGE("%s%d", "父进程,native pid = ", getpid());
    } else {
        ("com.fork.pronative");
        LOGE("%s%d", "子进程 native pid = ", getpid());
        }
    return pid;
    }

  // Java
    int mainP = Process.myPid();
    Log.e("tag", "主进程----> " + mainP);
    //子进程拥有父进程当前运行到的位置
    int forkId = fork();
    Log.e("tag", "forkId: " + forkId + "   当前进程Id：" + Process.myPid() + " ----->" + "fork结束了");
    Log.e("tag", "mainP: " + mainP);

输出日志：

主进程----> 7371
当前进程 native ID= 7371
当前进程的父进程 native ID= 652
父进程,native pid = 7371
forkId: 7630   当前进程Id：7371 ----->fork结束了
mainP: 7371
子进程 native pid = 7630
forkId: 0   当前进程Id：7630 ----->fork结束了
mainP: 7371

非常简单代码，我们是直接通过JNI调用了系统的API fork函数，就完成了创建新的进程，简单画图：

fork_p.png

由fork创建的新进程被称为子进程（child process）。该函数被调用一次，但返回两次。两次返回的区别是子进程的返回值是0，而父进程的返回值则是新进程（子进程）的进程 id。将子进程id返回给父进程的理由是：因为一个进程的子进程可以多于一个，没有一个函数使一个进程可以获得其所有子进程的进程id。对子进程来说，之所以fork返回0给它，是因为它随时可以调用getpid()来获取自己的pid；也可以调用getppid()来获取父进程的id。(进程id 0总是由交换进程使用，所以一个子进程的进程id不可能为0 )。
fork之后，操作系统会复制一个与父进程完全相同的子进程，虽说是父子关系，但是在操作系统看来，他们更像兄弟关系。
2个进程共享代码空间，但是数据空间是互相独立的。
子进程数据空间中的内容是父进程的完整拷贝，指令指针也完全相同，子进程拥有父进程当前运行到的位置2个进程的程序计数器pc值相同，即子进程是从fork返回处开始执行的。
如果fork成功，子进程中fork的返回值是0，父进程中fork的返回值是子进程的进程号，如果fork不成功，父进程会返回错误。
可以这样想象，2个进程一直同时运行，而且步调一致，在fork之后，他们分别作不同的工作，也就是分岔（fork）了，用过github都知道fork，分支的意思，这里的fork也是分支的意思。这也是fork为什么叫fork的原因。

android系统启动流程图

android 系统启动流程.png

Zygote是什么？

Zygote是由linux init进程启动时创建的，它又称为受精卵，它可以通过fork（孵化进程）的形式来创建应用程序进程和SystemServer进程。并且，Zygote进程在启动的时候会创建dvm，因此通过fork而创建的应用程序进程和SystemServer进程可以在内部获取一个dvm或者art的实例副本，看下面的大概的流程图：

System.png

Zygote进程启动流程

在Android中，所有应用程序的进程和系统服务进程都是由Zygote进程通过fork子进程产生的，Zygote进程包含着已经预加载的系统资源和dvm或art，所以通过fork出来的子进程也就具有Zygote进程的所有东西，减轻了每次系统新建进程时的压力。

Zygote进程是如何被启动的？查看官方源码

在system/core/rootdir目录下有不同的配置文件，由Android初始化语言(Android Init Language)编写的脚本，primaryZygote和secondaryZygote分别对应主模式和副模式，例如init.zygote64_32.rc，这里主模式就是64位，副模式则是32位。目前来说一共有以下3个rc文件:

init.rc.png

这里以zygote64_32.rc为例源码如下: /system/core/rootdir/init.zygote64_32.rc

service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server --socket-name=zygote
class main
priority -20 // 优先级
user root    // 系统用户
group root readproc reserved_disk
socket zygote stream 660 root system // 660 权限 只有拥有者有读写权限；而属组用户和其他用户只有读权限。
socket usap_pool_primary stream 660 root system
onrestart write /sys/power/state on
onrestart restart audioserver  // 重启音频服务
onrestart restart cameraserver // 重启摄像头服务
onrestart restart media // 重启媒体服务
onrestart restart netd  // 重启网络服务
onrestart restart wificond  // 重启wifi服务
writepid /dev/cpuset/foreground/tasks // 创建子进程时，向 /dev/cpuset/foreground/tasks 写入pid


service zygote_secondary /system/bin/app_process32 -Xzygote /system/bin --zygote --socket-name=zygote_secondary --enable-lazy-preload
class main
priority -20
user root
group root readproc reserved_disk
socket zygote_secondary stream 660 root system
socket usap_pool_secondary stream 660 root system
onrestart restart zygote
writepid /dev/cpuset/foreground/tasks

上面的脚本的意思就是：

通过service命令创建zygote进程，zygote进程对应的路径为system/bin/app_process，启动的入口即是class main所指的main函数，而app_process对应的代码定义在app_main.cpp中,而-Xzygote /system/bin --zygote --start-system-server --socket-name=zygote 这些是main函数的参数。
service 是 linux 启动进程的命令，service 是 init 加载的和是退出重启的（可选）程序。services（服务）是一个程序，以 service开头，由init进程启动，一般运行于另外一个init的子进程，所以启动service前需要判断对应的可执行文件是否存在。init生成的子进程，定义在rc文件，其中每一个service，在启动时会通过fork方式生成子进程。Services（服务）的形式如下：
```
service <name> <pathname> [ <argument> ]* <option> <option>
```

name:服务名
pathname:当前服务对应的程序位置
argument 可选参数
option：当前服务设置的选项

/frameworks/base/cmds/app_process/app_main.cpp

int main(int argc, char *const argv[]) {

//argc = argument 可选参数  -Xzygote /system/bin --zygote --start-system-server --socket-name=zygote
// argv = option：当前服务设置的选项 class main
// argv[0] =  /system/bin
AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
// Process command line arguments 处理命令行参数
// ignore argv[0] 忽略  argv[0]
argc--;
argv++;

// Everything up to '--' or first non '-' arg goes to the vm.
//
// The first argument after the VM args is the "parent dir", which
// is currently unused.
//
// After the parent dir, we expect one or more the following internal
// arguments :
//
// --zygote : Start in zygote mode  启动zygote的模式
// --start-system-server : Start the system server. 启动系统服务器。
// --application : Start in application (stand alone, non zygote) mode.在应用程序（独立，非zygote）模式下启动
// --nice-name : The nice name for this process.这个进程的名字。
//


// 对于非zygote启动，这些参数后跟主类名称。所有剩余的参数都传递到该类的main方法。
// For non zygote starts, these arguments will be followed by
// the main class name. All remaining arguments are passed to
// the main method of this class.
//


// 对于zygote启动，所有剩余的参数都传递给合子。主函数。
// For zygote starts, all remaining arguments are passed to the zygote.
// main function.
//
// Note that we must copy argument string values since we will rewrite the
// entire argument block when we apply the nice name to argv0.
//
// As an exception to the above rule, anything in "spaced commands"
// goes to the vm even though it has a space in it.



///...................................


// 解析运行时参数。停在第一个无法识别的选项。
// Parse runtime arguments.  Stop at first unrecognized option.
bool zygote = false;
bool startSystemServer = false;
bool application = false;
String8 niceName;
String8 className;

++i;  // Skip unused "parent dir" argument.
while (i < argc) {
    const char *arg = argv[i++];
    if (strcmp(arg, "--zygote") == 0) {// 是否是zygote模式启动进程，如果
        zygote = true;
        niceName = ZYGOTE_NICE_NAME;//进程名 = zygote
    } else if (strcmp(arg, "--start-system-server") == 0) {//是否启动system-service
        startSystemServer = true;
    } else if (strcmp(arg, "--application") == 0) {// 是否是启动application
        application = true;
    } else if (strncmp(arg, "--nice-name=", 12) == 0) {//进程名
        niceName.setTo(arg + 12);
    } else if (strncmp(arg, "--", 2) != 0) {
        className.setTo(arg);
        break;
    } else {
        --i;
        break;
    }
}

///.........................

if (zygote) {// 调用AppRuntime的start方法并把com.android.internal.os.ZygoteIni.java全类名当做参数传进去
    runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
} else if (className) {// 传的是应用的类名
    runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
} else {
    fprintf(stderr, "Error: no class name or --zygote supplied.\n");
    app_usage();
    LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
}
}

上述代码描述的这里runtime为AppRuntime类型，而AppRuntime又继承于AndroidRuntime，AppRuntime中并没有重写父类的start()方法，所以这里start()方法调用的是AndroidRuntime的start()方法。

AndroidRuntime.cpp

void AndroidRuntime::start(const char *className, const Vector <String8> &options, bool zygote) {

///...............

/// 开启Java虚拟机
if (startVm(&mJavaVM, &env, zygote, primary_zygote) != 0) {
    return;
}

///...............

/// classNameStr是传入的参数className转化而来，值为com.android.internal.os.ZygoteInit
classNameStr = env->NewStringUTF(className);
env->SetObjectArrayElement(strArray, 0, classNameStr);

///..........

/// 加载com/android/internal/os/ZygoteInit类，这是jni反射
jclass startClass = env->FindClass(slashClassName);

if (startClass == NULL) {
    ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
} else {
    // 通过反射拿到com/android/internal/os/ZygoteInit的main函数
    jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
                                                 "([Ljava/lang/String;)V");
    if (startMeth == NULL) {
        ///.....
    } else {
        /// 反射调用com/android/internal/os/ZygoteInit的main函数， 从Native层进入了Java层
        env->CallStaticVoidMethod(startClass, startMeth, strArray);
    }
}

}

frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

从这里开始就进入了Java层,从前面的runtime.start("com.android.internal.os.ZygoteInit", args, zygote);可知最后通过反射调用了ZygoteInit.main()，我们再来看看这个ZygoteInit.main()又是什么：

public static void main(String argv[]) {
    ZygoteServer zygoteServer = null;

    // 确保创建线程会抛出异常 因为Zygote初始化时是单线程运行的
    ZygoteHooks.startZygoteNoThreadCreation();
    try {
        // 设置Zygote自己的进程组
        Os.setpgid(0, 0);
    } catch (ErrnoException ex) {
        throw new RuntimeException("Failed to setpgid(0,0)", ex);
    }

    Runnable caller;
    try {
        // 是否系统进程
        boolean startSystemServer = false;
        String zygoteSocketName = "zygote";
        String abiList = null;
        boolean enableLazyPreload = false;
        for (int i = 1; i < argv.length; i++) {
            // init.zygote64_32.rc的参数传到这里了
            if ("start-system-server".equals(argv[i])) {
                startSystemServer = true;
            } else if ("--enable-lazy-preload".equals(argv[i])) {
                enableLazyPreload = true;
            } else if (argv[i].startsWith(ABI_LIST_ARG)) {
                // app_main.cpp 读取abi list的文件然后append到参数中 在这里解析
                abiList = argv[i].substring(ABI_LIST_ARG.length());
            } else if (argv[i].startsWith(SOCKET_NAME_ARG)) {
                // socketName也在app_main.cpp中被设置
                zygoteSocketName = argv[i].substring(SOCKET_NAME_ARG.length());
            } else {
                throw new RuntimeException("Unknown command line argument: " + argv[i]);
            }
        }

        // Zygote.PRIMARY_SOCKET_NAME = "zygote";
        final boolean isPrimaryZygote = zygoteSocketName.equals(Zygote.PRIMARY_SOCKET_NAME);


        if (!enableLazyPreload) {
            //.............................
            // 预加载资源，preload方法在下面展开
            preload(bootTimingsTraceLog);

            // ...............
        } else {
            // 设置线程优先级为NORM_PRIORITY = 5;
            Zygote.resetNicePriority();
        }

        // 回收一些前面预加载资源的内存
        gcAndFinalize();

        Zygote.initNativeState(isPrimaryZygote);

        // 从这里开始可以创建新线程了
        ZygoteHooks.stopZygoteNoThreadCreation();

        // 创建Server端等待之后的AMS等进程连接
        zygoteServer = new ZygoteServer(isPrimaryZygote);

        if (startSystemServer) {
            // 先fork一个SystemServer进程出来，在下面展开
            // 这里的r其实就是handleSystemServerProcess()方法，并且父进程是返回null
            Runnable r = forkSystemServer(abiList, zygoteSocketName, zygoteServer);

            if (r != null) {//子进程执行到这里基本就结束了，后续大代码是fork也就是父进程的执行的
                r.run();
                return;
            }
        }

        // 阻塞等待客户端连接请求
        caller = zygoteServer.runSelectLoop(abiList);
    } catch (Throwable ex) {
        Log.e(TAG, "System zygote died with exception", ex);
        throw ex;
    } finally {
        if (zygoteServer != null) {
            zygoteServer.closeServerSocket();
        }
    }

    // 子进程执行返回的caller对象，父进程只会阻塞获取连接请求或者处理fork请求
    if (caller != null) {
        caller.run();
    }
}

预加载系统资源 preload方法

 static void preload(TimingsTraceLog bootTimingsTraceLog) {
    beginPreload();
    // 加载/system/etc/preloaded-classes目录下的class文件
    // PRELOADED_CLASSES = "/system/etc/preloaded-classes";
    preloadClasses();


    // 加载许多应用程序使用的类，但不能放在启动类路径（ boot classpath）中的内容。
    // 这里主要加载两个jar文件
    // /system/framework/android.hidl.base-V1.0-java.jar
    // /system/framework/android.hidl.manager-V1.0-java.jar
    cacheNonBootClasspathClassLoaders();

    // 加载一些资源文件，加载常用资源，以便可以在各个进程之间共享它们。
    preloadResources();

    // 最终调用 frameworks/native/libs/ui/GraphicBufferMapper.cpp的preloadHal()方法
    nativePreloadAppProcessHALs();

    // 通过一定的条件判断后决定调用navtive层frameworks/native/opengl/libagl/egl.cpp 的eglGetDisplay方法
    maybePreloadGraphicsDriver();
    // 加载一些共享库 android compiler_rt jnigraphics
    preloadSharedLibraries();
    // 设置文字的一些效果以缓存文字描绘
    // 在native层做一些初始化 frameworks/base/core/jni/android_text_Hyphenator.cpp init()方法
    preloadTextResources();

    // 加载webviewchromium_loader库
    WebViewFactory.prepareWebViewInZygote();

    // 转换为软引用 让 Zygote GC时可以回收
    // 即调用gcAndFinalize()方法的时候
    endPreload();
    warmUpJcaProviders();
    
    sPreloadComplete = true;
}

通过zygote fork出系统进程 forkSystemServer方法

 private static Runnable forkSystemServer(String abiList, String socketName,
                                         ZygoteServer zygoteServer) {
    // .........................


    int pid;

    try {


        //请求派生系统服务器进程
        // fork SystemServer进程
        // 调用native方法 nativeForkSystemServer()
        pid = Zygote.forkSystemServer(
                parsedArgs.mUid, parsedArgs.mGid,
                parsedArgs.mGids,
                parsedArgs.mRuntimeFlags,
                null,
                parsedArgs.mPermittedCapabilities,
                parsedArgs.mEffectiveCapabilities);
    } catch (IllegalArgumentException ex) {
        throw new RuntimeException(ex);
    }

    // pid为0则为子进程 pid > 0为父进程
    // 父进程返回子进程的pid
    if (pid == 0) {
        if (hasSecondZygote(abiList)) {
            waitForSecondaryZygote(socketName);
        }
        //因为子进程都是从zygote进程(父进程)复制的所有内容，子进程不要这些，所以需要关闭，以免浪费资源
        zygoteServer.closeServerSocket();
        return handleSystemServerProcess(parsedArgs);
    }

    return null;
}

frameworks/base/core/java/com/android/internal/os/ZygoteServer.java

 Runnable runSelectLoop(String abiList) {
    while (true) {

        try {
            // 这里阻塞获取事件 主要原理是Linux的I/O复用技术
            Os.poll(pollFDs, -1);
        } catch (ErrnoException ex) {
            throw new RuntimeException("poll failed", ex);
        }


        while (--pollIndex >= 0) {

            // 等于0即为ZygoteSever自身的socket 用来处理连接请求
            // 然后存入peers即ZygoteConnection的数组中
            // 其实就是系统服务在ZygoteServer这里注册的过程
            if (pollIndex == 0) {
                // Zygote server socket
                ZygoteConnection newPeer = acceptCommandPeer(abiList);
                peers.add(newPeer);
                socketFDs.add(newPeer.getFileDescriptor());

            } else if (pollIndex < usapPoolEventFDIndex) {
                // ZygoteServer已经连接好的的fd
                // 其实这里就是看看有没有socket发出fork子进程请求的过程
                try {
                    ZygoteConnection connection = peers.get(pollIndex);

                    // 这里就是处理fork子进程请求的地方
                    final Runnable command = connection.processOneCommand(this);

                    if (mIsForkChild) {
                        if (command == null) {
                            throw new IllegalStateException("command == null");
                        }
                        return command;
                    } else {
                        if (command != null) {
                            throw new IllegalStateException("command != null");
                        }

                        // 检测这个connection是否关闭了，如果关闭就从数组中移除
                        // 防止下次再读这个connection的时候已经关闭了
                        if (connection.isClosedByPeer()) {
                            connection.closeSocket();
                            peers.remove(pollIndex);
                            socketFDs.remove(pollIndex);
                        }
                    }
                } catch (Exception e) {
                } else{
                    
                }
            }
        }

runSelectLoop最主要的核心点是processOneCommand()方法，用来处理服务进程fork()子进程的请求，processOneCommand方法后续结合startActivity创建应用进程才会好讲，因为processOneCommand是在socket中监听专门处理fork出子进程，所以我们要结合startActivity第一次启动fork子进程开始讲解。

android 系统启动流程.png

Android系统启动Zygote进程(api 29)

dvm，app进程，linux进程三者关系？

Linux fork的原理

android系统启动流程图

Zygote是什么？

Zygote进程启动流程

Zygote进程是如何被启动的？查看官方源码

/frameworks/base/cmds/app_process/app_main.cpp

AndroidRuntime.cpp

frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

frameworks/base/core/java/com/android/internal/os/ZygoteServer.java

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读