Zygote源码分析

Android启动从init.rc开始，最开始启动ServiceManager

service servicemanager /system/bin/servicemanager
    class core
    user system
    group system
    critical
    onrestart restart healthd
    onrestart restart zygote
    onrestart restart media
    onrestart restart surfaceflinger
    onrestart restart drm

zygote的启动实际是init.zygote32.rc文件

service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
    class main
    socket zygote stream 660 root system
    onrestart write /sys/android_power/request_state wake
    onrestart write /sys/power/state on
    onrestart restart media
    onrestart restart netd

之后，会走到app_main.cpp的main函数，在这里对参数进行解析，创建决定下一步的运行函数ZygoteInit

    AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
    
    if (zygote) {
        runtime.start("com.android.internal.os.ZygoteInit", args);
    } else if (className) {
        runtime.start("com.android.internal.os.RuntimeInit", args);
    } else {
        fprintf(stderr, "Error: no class name or --zygote supplied.\n");
        app_usage();
        LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
        return 10;
    }

AppRuntime继承于AndroidRuntime

class AppRuntime : public AndroidRuntime{

}

在AndroidRuntime的start方法中对虚拟机进行初始化，同时运行到ZygoteInit的main函数

void AndroidRuntime::start(const char* className, const Vector<String8>& options){
    // startVm内部最终调用 
    // JNI_CreateJavaVM(pJavaVM, pEnv, &initArgs)
    if (startVm(&mJavaVM, &env) != 0) {
		return;
	}
	
	// 寻找到要启动的类，这里就是ZygoteInit
	jclass startClass = env->FindClass(slashClassName);
	
	// 运行main函数
	jmethodID startMeth = env->GetStaticMethodID(startClass, "main","([Ljava/lang/String;)V");
	env->CallStaticVoidMethod(startClass, startMeth, strArray);

	// 释放虚拟机
	mJavaVM->DestroyJavaVM() != 0
}

在ZygoteInit的main方法中，首先初始化socket用于通讯,之后预加载类，资源和库，并开启SystemServer,之后进入监听socket消息循环

registerZygoteSocket(socketName);
preload();
startSystemServer(abiList, socketName);
runSelectLoop(abiList)

startSystemServer函数通过zygote进场fork出一个子进程

pid = Zygote.forkSystemServer(
                    parsedArgs.uid, parsedArgs.gid,
                    parsedArgs.gids,
                    parsedArgs.debugFlags,
                    null,
                    parsedArgs.permittedCapabilities,
                    parsedArgs.effectiveCapabilities);

在子进程中调用 handleSystemServerProcess(parsedArgs)函数，在这个函数中通过classloader加载类，同时运行到main函数，也就是SystemServer的main函数中去

final String systemServerClasspath = Os.getenv("SYSTEMSERVERCLASSPATH");

ClassLoader cl = null;
cl = new PathClassLoader(systemServerClasspath, ClassLoader.getSystemClassLoader());
RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);

invokeStaticMain(args.startClass, args.startArgs, classLoader);

再回到ZygoteInit的main函数的runSelectLoop中，这个函数中有一个while死循环，在循环中不断监听socket,并调用ZygoteConnection的runOnce函数。

while(true){
	done = peers.get(index).runOnce();
}

在runOnce中，fork出进程

pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,
                    parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,
                    parsedArgs.niceName, fdsToClose, parsedArgs.instructionSet,
                    parsedArgs.appDataDir);

在子进程中

handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);

在这个函数中，首先会关闭socket，之后运行到RuntimeInit.zygoteInit

RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, null /* classLoader */)

在这里进行初始化

        commonInit();
        nativeZygoteInit();
        applicationInit(targetSdkVersion, argv, classLoader);

在nativeZygoteInit中，会调到app_main的onZygoteInit中，这里进行了binder的初始化

    virtual void onZygoteInit()
    {
        // Re-enable tracing now that we're no longer in Zygote.
        atrace_set_tracing_enabled(true);

        sp<ProcessState> proc = ProcessState::self();
        ALOGV("App process: starting thread pool.\n");
        proc->startThreadPool();
    }

在applicationInit中调用invokeStaticMain运行到main函数