Zygote进程源码分析

piziliul

已于 2024-10-31 10:55:20 修改

阅读量591

点赞数 5

于 2024-10-31 10:54:59 首次发布

本文链接：https://blog.youkuaiyun.com/piziliul/article/details/143382717

版权

Android Framework 专栏收录该内容

5 篇文章

订阅专栏

Zygote启动流程

在这里插入图片描述流程接口说明:

init进程的main接口中,开始启动Zygote进程(app_main.cpp)

int main(int argc, char* const argv[])
{
   ...
    while (i < argc) {
        const char* arg = argv[i++];
        if (strcmp(arg, "--zygote") == 0) { 
            zygote = true; 
            //zygote进程重新命名
            niceName = ZYGOTE_NICE_NAME;
        } else if (strcmp(arg, "--start-system-server") == 0) { 
            startSystemServer = true; 
        } 
        ...
    }
    ...
    if (!niceName.isEmpty()) {
        runtime.setArgv0(niceName.string(), true /* setProcName */);
    }
    // 启动Zygote进程
    if (zygote) { 
        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.");
    }
}

AndroidRuntime启动Zygote进程

void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
   ...
       
    /* start the virtual machine */
    JniInvocation jni_invocation;
    jni_invocation.Init(NULL);
    JNIEnv* env;

    if (startVm(&mJavaVM, &env, zygote, primary_zygote) != 0) {
        return;
    }
    onVmCreated(env);
    

    if (startReg(env) < 0) {
        ALOGE("Unable to register all android natives\n");
        return;
    }
    
    jclass stringClass;
    jobjectArray strArray;
    jstring classNameStr;

    stringClass = env->FindClass("java/lang/String");
    assert(stringClass != NULL);

    strArray = env->NewObjectArray(options.size() + 1, stringClass, NULL);
    assert(strArray != NULL);

    classNameStr = env->NewStringUTF(className);
    assert(classNameStr != NULL);
    env->SetObjectArrayElement(strArray, 0, classNameStr);

    for (size_t i = 0; i < options.size(); ++i) {
        jstring optionsStr = env->NewStringUTF(options.itemAt(i).string());
        assert(optionsStr != NULL);
        env->SetObjectArrayElement(strArray, i + 1, optionsStr);
    }

    char* slashClassName = toSlashClassName(className != NULL ? className : "");
    jclass startClass = env->FindClass(slashClassName);
    if (startClass == NULL) {
        ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
        /* keep going */
    } else {

        jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
            "([Ljava/lang/String;)V");
        if (startMeth == NULL) {
            ALOGE("JavaVM unable to find main() in '%s'\n", className);
            /* keep going */
        } else {

            env->CallStaticVoidMethod(startClass, startMeth, strArray);

#if 0
            if (env->ExceptionCheck())
                threadExitUncaughtException(env);
#endif
        }
    } 
   ...
}

Zygote进程的main函数,此时已从Native层进入到Java层

public static void main(String argv[]) {
    ZygoteServer zygoteServer = new ZygoteServer();
    ...
    try {
        ...
        // 注册Socket,用于Zygote与SystemServer之间通信,创建进程,该进程通信方案为Socket
        zygoteServer.registerServerSocket(socketName);

        if (!enableLazyPreload) {
            ...
            preload(bootTimingsTraceLog);
            ...
        } else {
            ...
        }

        ...

        if (startSystemServer) {
            // 创建SystemServer进程
            Runnable r = forkSystemServer(abiList, socketName, zygoteServer);
            if (r != null) {
                r.run();
                return;
            }
        }

        // 等待AMS创建新的进程
        caller = zygoteServer.runSelectLoop(abiList);
    } catch (Throwable ex) {
        Log.e(TAG, "System zygote died with exception", ex);
        throw ex;
    } finally {
        zygoteServer.closeServerSocket();
    }
    ...
}

SystemServer启动AMS PMS WMS服务

SystemServer进程的入口函数

/**
 * The main entry point from zygote.
 */
public static void main(String[] args) {
    new SystemServer().run();
}

SystemServer的run方法中调用startBootstrapServices实现AMS&PMS服务的添加启动

private void run() {
    TimingsTraceAndSlog t = new TimingsTraceAndSlog();
    try {
        ...
        // 创建SystemServiceManager并添加到本地服务中并添加到本地服务中
        mSystemServiceManager = new SystemServiceManager(mSystemContext);
        mSystemServiceManager.setStartInfo(mRuntimeRestart,
                mRuntimeStartElapsedTime, mRuntimeStartUptime);
        LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
        ...
    } finally {
        t.traceEnd();  // InitBeforeStartServices
    }

    // Setup the default WTF handler
    RuntimeInit.setDefaultApplicationWtfHandler(SystemServer::handleEarlySystemWtf);

    // Start services.
    try {
        t.traceBegin("StartServices");
        //添加 AMS PMS
        startBootstrapServices(t);
        startCoreServices(t);
        startOtherServices(t);
    } catch (Throwable ex) {
        Slog.e("System", "******************************************");
        Slog.e("System", "************ Failure starting system services", ex);
        throw ex;
    } finally {
        t.traceEnd(); // StartServices
    }
    ...
}

添加AMS&PMS

private void startBootstrapServices(@NonNull TimingsTraceAndSlog t) {
    ...
    // TODO: Might need to move after migration to WM.
    // AMS初始化
    ActivityTaskManagerService atm = mSystemServiceManager.startService(
        ActivityTaskManagerService.Lifecycle.class).getService();
    mActivityManagerService = ActivityManagerService.Lifecycle.startService(
        mSystemServiceManager, atm);
    mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
    mActivityManagerService.setInstaller(installer);
    mWindowManagerGlobalLock = atm.getGlobalLock();
    t.traceEnd();
    ...
    // PMS 初始化
    try {
        Watchdog.getInstance().pauseWatchingCurrentThread("packagemanagermain");
        mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
                mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
    } finally {
        Watchdog.getInstance().resumeWatchingCurrentThread("packagemanagermain");
    }

    ...
    // watchdog看门狗,初始化AMS,
    watchdog.init(mSystemContext, mActivityManagerService);
    ...
}

系统关键类说明

SystemServer进程是系统进程，很多系统服务，例如ActivityManagerService、PackageManagerService、WindowManagerService…都是存在该进程被创建后启动
ActivityManagerServices（AMS）：是一个服务端对象，负责所有的Activity的生命周期，AMS通过Binder与Activity通信，而AMS与Zygote之间是通过Socket通信
ActivityThread：UI线程/主线程，它的main()方法是APP的真正入口
ApplicationThread：一个实现了IBinder接口的ActivityThread内部类，用于ActivityThread和AMS的所在进程间通信
Instrumentation：可以理解为ActivityThread的一个工具类，在ActivityThread中初始化，一个进程只存在一个Instrumentation对象，在每个Activity初始化时，会通过Activity的Attach方法，将该引用传递给Activity。Activity所有生命周期的方法都有该类来执行

Zygote关键问题

init进程的作用
- 遍历inti.rc文件,根据其中的启动参数,执行响应的命令
- 重命名Zygote进程并启动Zygote进程
Zygote进程的由来(原始进程是什么)
- 原始进程名为:app_process,其在inti进程中对该进程重命名为zygote,通过设置niceName重新命名
Zygote进程通信的方案(Socket,为什么不采用Binder)
- Zygote进程通信采用的是Socket通信
每个App都会使用到系统资源,系统资源是否都会加载一次
PMS&AMS的作用
如果没有PMS&AMS,如果加载应用
- 遍历data/app的文件夹,查找apk文件
- 解压apk文件
- dom解析manifest.xml
- 定位到Activity,用于启动指定页面
- class内存
- 实例化对象,并展示
  由此可以看出应用的加载涉及多个步骤,其中PMS负责查找Apk,并解压apk文件,解析文件信息,AMS负责定位页面,并加载class到内存中,实例化对象,然后展示,所以两者缺一不可