Android之Zygote

Zygote是什么

Zygote是一个守护进程服务，SystemServer和其他所有的Dalvik虚拟机进程都是由Zygote fork出来的。

Zygote是Android中最重要的一个进程，和Init进程，SystemServer进程是支撑Android世界的三极。Zygote进程在Init进程中以service的方式启动的。

Zygote是一个C/S模型，Zygote进程作为服务端，其他进程作为客户端向它发出“孵化”请求，而Zygote接收到这个请求后就“孵化”出一个新的进程。如图所示，当点击Launcher里的应用程序图标去启动一个新的应用程序进程时，这个请求会到达框架层的核心服务ActivityManagerService中，当AMS收到这个请求后，它通过调用Process类发出一个“孵化”子进程的Socket请求，而Zygote监听到这个请求后就立刻fork一个新的进程出来。
 

Zygote的启动流程

Zygote进程对应的主文件为app_main.cpp，当他被Init进程启动起来之后，就会进入主文件app_main.cpp的main()函数。接下来它的main函数开始分析Zygote进程的启动：

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;
            //ZYGOTE_NICE_NAME字符串内容就是“Zygote”，此处已被换名字
        } else if (strcmp(arg, "--start-system-server") == 0) {
            startSystemServer = true;
            //在init.rc里配置了前面的这些参数，而Zygote进程启动的时候，
            //Init进程会传过来这些参数，所以此处把变量startSystemServer
            //设置为true代表启动SystemServer
        } else if (strcmp(arg, "--application") == 0) 
        .......
    }
    ......

    if (zygote) {
        runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
        //zygote为true代表的是Zygote进程，也就是说现在正在启动的是Zygote进程，
        //我们知道Zygote进程用于孵化子进程，Zygote进程孵化子进程是通过自己的资源赋值一份，
        //来fork一个新的子进程，也就是说子进程也会进入这个文件的main函数，因此，
        //这里的main函数被调用并不只是Zygote启动的时候被调用。这里通过zygote这个变量来区分，
        //如果是Zygote进程本身，就会进入到if里，否则就会进入到下面的else if里，代表字进程启动。
    } else if (className) {
        runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
    } else {
        .......
    }
}

main()函数最后调用runtime的start()函数，runtime是一个AppRuntime对象，看看AppRuntime类：

class AppRuntime : public AndroidRuntime
{
    .......
}

AppRuntime类继承AndroidRuntime类，因此前面调用的runtime的start()函数就会进入AndroidRuntime的start()函数，下面看看该函数：

void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
    ......
    JniInvocation jni_invocation;
    jni_invocation.Init(NULL);
    JNIEnv* env;
    //启动VM
    if (startVm(&mJavaVM, &env, zygote) != 0) {
        return;
    }
    onVmCreated(env);

    //注册JNI函数
    if (startReg(env) < 0) {
        ALOGE("Unable to register all android natives\n");
        return;
    }
    ....
    //className由上一步传递过来，“com.android.internal.os.ZygoteInit”或者“com.android.internal.os.RuntimeInit”
    char* slashClassName = toSlashClassName(className != NULL ? className : "");
    jclass startClass = env->FindClass(slashClassName);
    if (startClass == NULL) {
        ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
    } else {
        //表明要调用的是类的main()函数
        jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
            "([Ljava/lang/String;)V");
        if (startMeth == NULL) {
            ALOGE("JavaVM unable to find main() in '%s'\n", className);
        } else {
            //调用ZygoteInit的main()函数或RuntimeInit的main()函数
            env->CallStaticVoidMethod(startClass, startMeth, strArray);
    .......
}

AndroidRuntime的start()函数主要做了以下三件事情： 
1. 调用startVM()函数启动虚拟机 
2. 调用startReg()函数注册JNI方法 
3. 调用com.android.internal.os.ZygoteInit类的main()函数（若是子进程，则调用com.android.internal.os.RuntimeInit的main()函数，从而基本结束初始化。而Zygote进程的main函数则还有以下的会讲到的5项工作）

下面一一介绍三个函数的具体工作：

启动虚拟机

通过调用startVM()函数启动虚拟机：

int AndroidRuntime::startVm(JavaVM** pJavaVM, JNIEnv** pEnv, bool zygote)
{
    ......
    //通过调用JNI_CreateJavaVM()创建虚拟机，如果对这个感兴趣，可以去研究下art虚拟机
    if (JNI_CreateJavaVM(pJavaVM, pEnv, &initArgs) < 0) {
        ALOGE("JNI_CreateJavaVM failed\n");
        return -1;
    }
    ......
}

注册JNI方法

在Android中，Java世界要调用native世界的函数就要用JNI机制，并且在Android系统中也大量使用JNI机制，Android系统通过如下的startReg()函数去注册：

/*static*/ int AndroidRuntime::startReg(JNIEnv* env)
{
    ......
    if (register_jni_procs(gRegJNI, NELEM(gRegJNI), env) < 0) {
        env->PopLocalFrame(NULL);
        return -1;
    }
    .......
}

startReg()函数通过调用register_jni_procs()函数去进一步注册，传递的值是gRegJNI数组，原生Android6.0版本该数组超过130个，具体如下：

static const RegJNIRec gRegJNI[] = {
    REG_JNI(register_com_android_internal_os_RuntimeInit),
    REG_JNI(register_com_android_internal_os_ZygoteInit),
    REG_JNI(register_android_os_SystemClock),
    REG_JNI(register_android_util_EventLog),
    REG_JNI(register_android_util_Log),
    REG_JNI(register_android_util_MemoryIntArray),
    REG_JNI(register_android_util_PathParser),
    REG_JNI(register_android_app_admin_SecurityLog),
    REG_JNI(register_android_content_AssetManager),
    REG_JNI(register_android_content_StringBlock),
    REG_JNI(register_android_content_XmlBlock),
    REG_JNI(register_android_text_AndroidCharacter),
    REG_JNI(register_android_text_StaticLayout),
    REG_JNI(register_android_text_AndroidBidi),
    REG_JNI(register_android_view_InputDevice),
    REG_JNI(register_android_view_KeyCharacterMap),
    REG_JNI(register_android_os_Process),
    REG_JNI(register_android_os_SystemProperties),
    REG_JNI(register_android_os_Binder),
    REG_JNI(register_android_os_Parcel),
    ......
}

上面所列的JNI都通过register_jni_procs()函数来注册：

static int register_jni_procs(const RegJNIRec array[], size_t count, JNIEnv* env)
{
    for (size_t i = 0; i < count; i++) {
        if (array[i].mProc(env) < 0) {
#ifndef NDEBUG
            ALOGD("----------!!! %s failed to load\n", array[i].mName);
#endif
            return -1;
        }
    }
    return 0;
}

通过循环对所有的JNI函数进行注册。。。

ZygoteInit负责Zygote的初始化。下面是ZygoteInit类的main方法

 public static void main(String argv[]) {
    // Mark zygote start. This ensures that thread creation will throw
    // an error.
    ZygoteHooks.startZygoteNoThreadCreation();

    try {
        Trace.traceBegin(Trace.TRACE_TAG_DALVIK, "ZygoteInit");
		//开启DDMS
        RuntimeInit.enableDdms();
        // Start profiling the zygote initialization.
        SamplingProfilerIntegration.start();

		....
       
		//1）注册zygote的socket监听端口
        registerZygoteSocket(socketName);
        Trace.traceBegin(Trace.TRACE_TAG_DALVIK, "ZygotePreload");
        EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,
            SystemClock.uptimeMillis());
		//2)预加载系统资源
        preload();
        EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,
            SystemClock.uptimeMillis());
        Trace.traceEnd(Trace.TRACE_TAG_DALVIK);

        ....
		
		//3）启动startServier进程
        if (startSystemServer) {
            startSystemServer(abiList, socketName);
        }

        Log.i(TAG, "Accepting command socket connections");
		//4）进入监听和接受消息的循环
        runSelectLoop(abiList);

        closeServerSocket();
    } catch (MethodAndArgsCaller caller) {
        caller.run();
    } catch (RuntimeException ex) {
    }
}

主要做了以下几件事：

1）注册zygote的socket端口监听；

2）预加载系统资源；

3）启动SystemServer进程；

4）进入监听和接受消息的循环；

依次看下这四个方法：

1）registerZygoteSocket()方法

private static void registerZygoteSocket(String socketName) {
    if (sServerSocket == null) {
        int fileDesc;
        final String fullSocketName = ANDROID_SOCKET_PREFIX + socketName;
        try {
            String env = System.getenv(fullSocketName);
            fileDesc = Integer.parseInt(env);
        }

        try {
            FileDescriptor fd = new FileDescriptor();
            fd.setInt$(fileDesc);
            sServerSocket = new LocalServerSocket(fd);
        } 
    }

创建一个本地的socket,然后等待调用runSelectLoop()来进入等待socket等待连接的循环中；

2）预加载系统资源，preload()方法；

先来看下Android应用进程共享内存图

通过上图可以很容易理解在Zygote进程预加载系统资源后，然后通过它孵化出其他的虚拟机进程，进而共享虚拟机内存和框架层资源，这样大幅度提高应用程序的启动和运行速度。 现在来看下preload()方法;

 static void preload() {
    Log.d(TAG, "begin preload");
    Trace.traceBegin(Trace.TRACE_TAG_DALVIK, "BeginIcuCachePinning");
    beginIcuCachePinning();
    Trace.traceEnd(Trace.TRACE_TAG_DALVIK);
    Trace.traceBegin(Trace.TRACE_TAG_DALVIK, "PreloadClasses");
	//2.1)预加载系统类
    preloadClasses();
    Trace.traceEnd(Trace.TRACE_TAG_DALVIK);
    Trace.traceBegin(Trace.TRACE_TAG_DALVIK, "PreloadResources");
	//2.2）预加载系统资源
    preloadResources();
    Trace.traceEnd(Trace.TRACE_TAG_DALVIK);
    Trace.traceBegin(Trace.TRACE_TAG_DALVIK, "PreloadOpenGL");
	//预加载OpenGL资源
    preloadOpenGL();
    Trace.traceEnd(Trace.TRACE_TAG_DALVIK);
	//2.3）预加载共享的so库
    preloadSharedLibraries();
    preloadTextResources();
    // Ask the WebViewFactory to do any initialization that must run in the zygote process,
    // for memory sharing purposes.
	//预加载WebView资源库
    WebViewFactory.prepareWebViewInZygote();
    endIcuCachePinning();
    warmUpJcaProviders();
    Log.d(TAG, "end preload");
}

主要是预加载各种系统资源，主要看下2.1）预加载系统类；2.2）预加载系统资源；2.3）预加载so库

2.1 preloadClasses();

private static final String PRELOADED_CLASSES = "/system/etc/preloaded-classes"; 
private static void preloadClasses() {
    final VMRuntime runtime = VMRuntime.getRuntime();

    InputStream is;
    try {
        is = new FileInputStream(PRELOADED_CLASSES);
    } catch (FileNotFoundException e) {
        Log.e(TAG, "Couldn't find " + PRELOADED_CLASSES + ".");
        return;
    }
   ....
    float defaultUtilization = runtime.getTargetHeapUtilization();
    runtime.setTargetHeapUtilization(0.8f);

    try {
        BufferedReader br= new BufferedReader(new InputStreamReader(is), 256);
        int count = 0;
        String line;
        while ((line = br.readLine()) != null) {
            // Skip comments and blank lines.
            line = line.trim();
            if (line.startsWith("#") || line.equals("")) {
                continue;
            }

        	 ......
            try {          
                //装载Java类信息
                Class.forName(line, true, null);
                count++;
            } catch (ClassNotFoundException e) {}
      .....
            
    } finally {
        Trace.traceBegin(Trace.TRACE_TAG_DALVIK, "PreloadDexCaches");
        runtime.preloadDexCaches();
        Trace.traceEnd(Trace.TRACE_TAG_DALVIK);
    }
}

去读PRELOADED_CLASSES文件下的文件，得到InputStream对象，在转换为BufferedReader，逐行读取文件的内容，每行通过trim(),过滤掉空行，然后调用 Class.forName()方法，加载Java类信息，而不是创建一个对象；

2.2 preloadResources();预加载系统资源

private static void preloadResources() {
    final VMRuntime runtime = VMRuntime.getRuntime();

    try {
        mResources = Resources.getSystem();
        mResources.startPreloading();
        if (PRELOAD_RESOURCES) {
           	//加载系统Drawable资源
            TypedArray ar = mResources.obtainTypedArray(com.android.internal.R.array.preloaded_drawables);
            int N = preloadDrawables(ar);
            ar.recycle();
            //加载系统颜色资源
            ar = mResources.obtainTypedArray(com.android.internal.R.array.preloaded_color_state_lists);
            N = preloadColorStateLists(ar);
            ar.recycle();    
        }
        mResources.finishPreloading();
    } catch (RuntimeException e) {
    }
}

2.3 preloadSharedLibraries();加载系统共享so库

private static void preloadSharedLibraries() {
    Log.i(TAG, "Preloading shared libraries...");
    System.loadLibrary("android");
    System.loadLibrary("compiler_rt");
    System.loadLibrary("jnigraphics");
}

3 startSystemServer() 启动SystemServer进程

private static boolean startSystemServer(String abiList, String socketName)
        throws MethodAndArgsCaller, RuntimeException {
    
	....
  	//3.1 为启动SystemServer进程准备参数
    String args[] = {
        "--setuid=1000",
        "--setgid=1000",
        "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1032,3001,3002,3003,3006,3007,3009,3010",
        "--capabilities=" + capabilities + "," + capabilities,
        "--nice-name=system_server",
        "--runtime-args",
        "com.android.server.SystemServer",
    };
    ZygoteConnection.Arguments parsedArgs = null;

    int pid;

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

		//3.2 fork出SystemServer进程
        /* Request to fork the system server process */
        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 */
    if (pid == 0) {
        if (hasSecondZygote(abiList)) {
            waitForSecondaryZygote(socketName);
        }
		//3.3 fork出SystemServer进程之后，初始化SystemServer进程
        handleSystemServerProcess(parsedArgs);
    }

    return true;
}

主要做了三件事，3.1）为启动SystemServer进程准备参数，可以看到SystemServer的进程Id和组Id均为1000，SystemServer的执行类是com.android.server.SystemServer；3.2）fork出SystemServer进程；3.3）fork出SystemServer进程之后，初始化SystemServer进程；
3.1 handleSystemServerProcess()方法

 private static void handleSystemServerProcess( ZygoteConnection.Arguments parsedArgs)
        throws ZygoteInit.MethodAndArgsCaller {
	//关闭zygote的socket
    closeServerSocket();
	//设置umask为0077；只有SystemServer进程可以访问；
    // set umask to 0077 so new files and directories will default to owner-only permissions.
    Os.umask(S_IRWXG | S_IRWXO);
	//由3.1可以看出nice-name=system_server，设置进程的名称为system_server；
    if (parsedArgs.niceName != null) {
        Process.setArgV0(parsedArgs.niceName);
    }

    final String systemServerClasspath = Os.getenv("SYSTEMSERVERCLASSPATH");
    if (systemServerClasspath != null) {
        performSystemServerDexOpt(systemServerClasspath);
    }
	
	//由3.1可以看出invokeWith为null;
    if (parsedArgs.invokeWith != null) {
        
    } else {
        ClassLoader cl = null;
        if (systemServerClasspath != null) {
            cl = createSystemServerClassLoader(systemServerClasspath,
                                               parsedArgs.targetSdkVersion);

            Thread.currentThread().setContextClassLoader(cl);
        }
        
        RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
    }
}

4）runSelectLoop()方法

private static void runSelectLoop(String abiList) throws MethodAndArgsCaller {
    ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
    ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();

    fds.add(sServerSocket.getFileDescriptor());
    peers.add(null);

    while (true) {
        StructPollfd[] pollFds = new StructPollfd[fds.size()];
        for (int i = 0; i < pollFds.length; ++i) {
            pollFds[i] = new StructPollfd();
            pollFds[i].fd = fds.get(i);
            pollFds[i].events = (short) POLLIN;
        }
        try {
            Os.poll(pollFds, -1);
        } catch (ErrnoException ex) {
            throw new RuntimeException("poll failed", ex);
        }
        for (int i = pollFds.length - 1; i >= 0; --i) {
            if ((pollFds[i].revents & POLLIN) == 0) {
                continue;
            }
			//4.1）接受连接请求
            if (i == 0) {
                ZygoteConnection newPeer = acceptCommandPeer(abiList);
                peers.add(newPeer);
                fds.add(newPeer.getFileDesciptor());
			//4.2) 接受消息
            } else {
                boolean done = peers.get(i).runOnce();
                if (done) {
                    peers.remove(i);
                    fds.remove(i);
                }
            }
        }
    }
}

主要做了两件事:

4.1）接受连接请求；i=0,说明请求连接的事件过来了，调用acceptCommandPeer()和客户端建立socket连接，然后加入监听数组，等待这个socket上命令的到来；

4.2）接受消息；i>0 说明已经连接上的socket已经有数据到了，调用ZygoteConnection类的runOnce()方法处理完成后，会断开和客户端的连接，并且从监听数组中移除；

 

 

Zygote的工作原理