Android5.0源码分析—— Zygote进程分析

1      Zygote简介

Android的应用程序一般都是由Java语言编写而成的，这样的应用程序需要运行在独自的Dalvik虚拟机之上（当然，5.0好像默认了ART了）。但是，如果在每一个进程启动时都在物理内存中创建和初始化一个Dalvik虚拟机，这无疑对系统的性能造成很大的影响。Zygote是Android系统中的一个非常重要的守护进程，所有其他应用程序的Dalvik虚拟机都是通过Zygote孵化出来的。通过这种方式，虚拟机的内存和框架层的资源被所有应用程序共享，从而提高了应用程序的启动和运行速度。下图为Android启动的大致流程。

图1. Android系统启动的大致流程

 

2     Zygote启动流程分析

2.1   Init进程分析

抛开硬件层的有关内容后，Android的源头应该为init进程。这个linux进程在操作系统的内核启动的后期就被启动了，并且之后所有的进程都是它的子孙进程。Init进程由main()开始，截取的部分代码如下：

int main(int argc, char **argv) {     ……     //创建并挂载了一些基本的系统文件     mkdir("/dev", 0755);     mkdir("/proc", 0755); mkdir("/sys", 0755);       mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");     mkdir("/dev/pts", 0755);     mkdir("/dev/socket", 0755);     mount("devpts", "/dev/pts", "devpts", 0, NULL);     mount("proc", "/proc", "proc", 0, NULL);     mount("sysfs", "/sys", "sysfs", 0, NULL);     ……     //初始化了部分属性     property_init();       ……     property_load_boot_defaults();       //加载了启动配置文件，即init.rc文件     init_parse_config_file("/init.rc");     //触发Action     action_for_each_trigger("early-init", action_add_queue_tail);       queue_builtin_action(wait_for_coldboot_done_action, "wait_for_coldboot_done");     queue_builtin_action(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng");     queue_builtin_action(keychord_init_action, "keychord_init");     queue_builtin_action(console_init_action, "console_init");     ……     queue_builtin_action(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng");     queue_builtin_action(property_service_init_action, "property_service_init");     queue_builtin_action(signal_init_action, "signal_init");     ……     for(;;) {         int nr, i, timeout = -1;           execute_one_command();//执行当前Command中的一个命令，Action和Service被启动         restart_processes(); //重新启动设置了重新启动标志位的进程         //监听来自属性服务的事件         if (!property_set_fd_init && get_property_set_fd() > 0) {             ufds[fd_count].fd = get_property_set_fd();             ufds[fd_count].events = POLLIN;             ufds[fd_count].revents = 0;             fd_count++;             property_set_fd_init = 1;         }         //监控singal，如果子进程异常退出，内核将抛出SIGCHILD信号，此时将可以对进程进行处理         //或是回收系统资源,或是重启子进程         if (!signal_fd_init && get_signal_fd() > 0) {             ufds[fd_count].fd = get_signal_fd();             ufds[fd_count].events = POLLIN;             ufds[fd_count].revents = 0;             fd_count++;             signal_fd_init = 1;         }         //监听来自keychord设备的事件，这是个组合按键设备         if (!keychord_fd_init && get_keychord_fd() > 0) {             ufds[fd_count].fd = get_keychord_fd();             ufds[fd_count].events = POLLIN;             ufds[fd_count].revents = 0;             fd_count++;             keychord_fd_init = 1;         }           ……         nr = poll(ufds, fd_count, timeout);//利用poll监听以上事件         if (nr <= 0)             continue;           for (i = 0; i < fd_count; i++) {             if (ufds[i].revents & POLLIN) {                 if (ufds[i].fd == get_property_set_fd())                     handle_property_set_fd();//处理属性服务相关事件                 else if (ufds[i].fd == get_keychord_fd())                     handle_keychord();//处理keychord事件                 else if (ufds[i].fd == get_signal_fd())                     handle_signal();//处理singal事件             }         }     }     return 0;

Zygote作为一个服务也被定义在了init.rc文件中，由init进程派生出来，配置代码截取在如下：

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

由于Zygote是由java的服务进程，其启动过程和其他在init.rc文件中定义的service启动不太一样。

2.2   App_main.cpp

通过配置信息可以定位Zygote的入口函数为app_main.cpp中的main，其代码截取如下：

 

int main(int argc, char* const argv[]) { …… //此类是AndroidRuntime的派生类     AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));     ……     while (i < argc) {//遍历Zygote的配置参数         const char* arg = argv[i++];         if (strcmp(arg, "--zygote") == 0) {//为进程更换名字             zygote = true;             niceName = ZYGOTE_NICE_NAME;         } else if (strcmp(arg, "--start-system-server") == 0) {//设置systemServer为true             startSystemServer = true;         } else if (strcmp(arg, "--application") == 0) {//设置application启动为true             application = true;         } else if (strncmp(arg, "--nice-name=", 12) == 0) {            ……         }     }     ……     if (zygote) {//如果配置参数中有参数显示需要启动Zygote,则ZygoteInit启动         runtime.start("com.android.internal.os.ZygoteInit", args);     } else if (className) {//否则RuntimeInit启动         runtime.start("com.android.internal.os.RuntimeInit", args);     } else {         ……     } }

可见，app_main.cpp中的main()最为主要的是创建了一个AppRuntime变量，接着调用了它的start()成员函数。AppRuntime类继承自AndroidRuntime类，它并没有实现自己的start()方法，因此调用的是AndroidRuntime ：：start()。而根据之前对App_main.cpp中main函数的分析，传入到AndroidRuntime.start()的参数存在两种情况：

1）runtime.start("com.android.internal.os.ZygoteInit",args)

2）runtime.start("com.android.internal.os.RuntimeInit",args)

因此可能存在两种不同的启动方式， “RuntimeInit”式启动时序大致如下图所示：

图2.  “RuntimeInit”式启动时序

由于在init.rc文件的Zygote服务已经配置了相关参数，因此这里只对ZygoteInit进行分析。AndroidRuntime.start()的主要作用是启动Android系统运行时库，代码截取如下：

void AndroidRuntime::start(const char* className, const Vector<String8>& options) {     ……//配置虚拟机的一些参数     JniInvocation jni_invocation;     jni_invocation.Init(NULL); JNIEnv* env; //开启虚拟机     if (startVm(&mJavaVM, &env) != 0) {         return; } //这里实际上是调用了子类AppRuntime的onVmCreate(env) onVmCreated(env); //注册Android JNI函数     if (startReg(env) < 0) {         ALOGE("Unable to register all android natives\n");         return;     }       //在开始调用main之前需要将参数转化成java可识别的类型，并将其全部存入一个数组     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); //找到需要启动的java类     jclass startClass = env->FindClass(slashClassName);     if (startClass == NULL) {         ALOGE("JavaVM unable to locate class '%s'\n", slashClassName); } else {         //得到指定类中指定方法的ID，这里得到的是ZygoteInit.main()的方法ID         jmethodID startMeth = env->GetStaticMethodID(startClass, "main",             "([Ljava/lang/String;)V");         if (startMeth == NULL) {             ALOGE("JavaVM unable to find main() in '%s'\n", className);         } else {             //调用上面得到的方法ID和相关参数，即调用Java类ZygoteInit.main();             env->CallStaticVoidMethod(startClass, startMeth, strArray);             ……         }     }     ……//回收资源关闭虚拟机等操作，这个函数除非进程退出，否则不会返回 }

AndroidRuntime.start()实际上主要做了3件事：1，startVM开启虚拟机；2，startReg()注册了JNI方法；3，调用Java方法。

2.3   ZygoteInit分析

ZygoteInit相关的类图结构大致如下：

图3.  ZygoteInit相关类图结构

根据init.rc中Zygote的配置参数，AndroidRuntime.start()最终调用的是ZgoteInit.main()。其代码截取如下：

public static void main(String argv[]) {         try {             ……             registerZygoteSocket(socketName);//初始化了server(zygote)的一个localsocket             EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,                 SystemClock.uptimeMillis());             preload();//加载了framwork.jar的class和资源到内存，这部分很占CPU             EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,                 SystemClock.uptimeMillis());               SamplingProfilerIntegration.writeZygoteSnapshot();               gc();//由于后续需要fork出应用程序的进程,需要进行垃圾回收以确保应用程序的性能               Trace.setTracingEnabled(false);               if (startSystemServer) {                 startSystemServer(abiList, socketName);//开启System server服务             }               Log.i(TAG, "Accepting command socket connections");             runSelectLoop(abiList);//开启循环               closeServerSocket();         } catch (MethodAndArgsCaller caller) {             caller.run();//这里实际上是真正开启了systemServer进程         } catch (RuntimeException ex) {             Log.e(TAG, "Zygote died with exception", ex);             closeServerSocket();             throw ex;         }     }

在ZygoteInit.main()中首先是调用了registerZygoteSocket(..)方法，该方法主要是为Zygote服务创建了一个localSocket。接着调用preload将class资源和系统的Resource加载到了内存中。之后利用gc()对垃圾进行回收。由于linux的写时复制机制，在fork出应用程序之前对垃圾进行回收可以最小化子进程的垃圾内存。之后，ZygoteInit.main()分别调用了startSystemServer()、runSelectLoop()方法。startSystemServer()开启了SystemServer，此进程是Zygote孵化出来的第一个java进程。而runSelectLoop()进入select的循环，用来响应其他应用程序（AMS）的请求。

2.4   Zygote启动SystemServer服务简要分析

SystemServer进程是Zygote 孵化出来的第一个进程，此进程有很多的系统进程，提供了所有核心的系统服务。与孵化其他进程不同，Zygote单独对SystemServer进程做了孵化工作。ZygoteInit.main()中调用了startSystemServer()，代码如下：

private static boolean startSystemServer(String abiList, String socketName)             throws MethodAndArgsCaller, RuntimeException {         long capabilities = posixCapabilitiesAsBits(             OsConstants.CAP_BLOCK_SUSPEND,             OsConstants.CAP_KILL,             OsConstants.CAP_NET_ADMIN,             OsConstants.CAP_NET_BIND_SERVICE,             OsConstants.CAP_NET_BROADCAST,             OsConstants.CAP_NET_RAW,             OsConstants.CAP_SYS_MODULE,             OsConstants.CAP_SYS_NICE,             OsConstants.CAP_SYS_RESOURCE,             OsConstants.CAP_SYS_TIME,             OsConstants.CAP_SYS_TTY_CONFIG         );         //SystemServer的启动参数设置         String args[] = {             "--setuid=1000",             "--setgid=1000",             "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1032,3001,3002,3003,3006,3007",             "--capabilities=" + capabilities + "," + capabilities,             "--runtime-init",             "--nice-name=system_server",             "com.android.server.SystemServer",         };         ZygoteConnection.Arguments parsedArgs = null;           int pid;           try {             parsedArgs = new ZygoteConnection.Arguments(args);             ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);             ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);               //向Zygote发送fork请求             pid = Zygote.forkSystemServer(                     parsedArgs.uid, parsedArgs.gid,                     parsedArgs.gids,                     parsedArgs.debugFlags,                     null,                     parsedArgs.permittedCapabilities,                     parsedArgs.effectiveCapabilities);         } catch (IllegalArgumentException ex) {             throw new RuntimeException(ex);         }           //以下代码仅对子进程SystemServer有效         if (pid == 0) {             if (hasSecondZygote(abiList)) {                 waitForSecondaryZygote(socketName);             }             handleSystemServerProcess(parsedArgs);         }         return true;     }

进入handleSystemServerProcess(parsedArgs)，从代码中可以看到Zygote根据请求创建了SystemServer进程，这个进程运行handleSystemServerProcess()。此函数对部分参数做了处理，并将剩余的参数传递给了SystemServer。

private static void handleSystemServerProcess(             ZygoteConnection.Arguments parsedArgs)             throws ZygoteInit.MethodAndArgsCaller {           closeServerSocket();         //设置默认权限         Os.umask(S_IRWXG | S_IRWXO);           if (parsedArgs.niceName != null) {             Process.setArgV0(parsedArgs.niceName);         }           final String systemServerClasspath = Os.getenv("SYSTEMSERVERCLASSPATH");         if (systemServerClasspath != null) {             performSystemServerDexOpt(systemServerClasspath);         }           if (parsedArgs.invokeWith != null) {             String[] args = parsedArgs.remainingArgs;             if (systemServerClasspath != null) {                 String[] amendedArgs = new String[args.length + 2];                 amendedArgs[0] = "-cp";                 amendedArgs[1] = systemServerClasspath;                 System.arraycopy(parsedArgs.remainingArgs, 0, amendedArgs, 2, parsedArgs.remainingArgs.length);             }             //一种可能的启动方式             WrapperInit.execApplication(parsedArgs.invokeWith,                     parsedArgs.niceName, parsedArgs.targetSdkVersion,                     null, args);         } else {//更为常见的启动方式             ClassLoader cl = null;             if (systemServerClasspath != null) {                 cl = new PathClassLoader(systemServerClasspath, ClassLoader.getSystemClassLoader());                 Thread.currentThread().setContextClassLoader(cl);             }             //将余下的参数传递给RuntimeInit.zygoteInit处理             RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);         }         //永远不会执行到这里     }

进入RuntimeInit.zygoteInit()

public static final void zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)             throws ZygoteInit.MethodAndArgsCaller {         if (DEBUG) Slog.d(TAG, "RuntimeInit: Starting application from zygote");         //重定向log         redirectLogStreams();          //初始化运行环境         commonInit();         //启动binder线程池         nativeZygoteInit();         //调用应用程序的入口函数         applicationInit(targetSdkVersion, argv, classLoader);     }

进入applicationInit()

private static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) throws ZygoteInit.MethodAndArgsCaller{         nativeSetExitWithoutCleanup(true);         ……         invokeStaticMain(args.startClass, args.startArgs, classLoader);     }

进入invokeStaticMain ()

private static void invokeStaticMain(String className, String[] argv, ClassLoader classLoader)             throws ZygoteInit.MethodAndArgsCaller {         //解析类名         Class<?> cl;         try {             cl = Class.forName(className, true, classLoader);         } catch (ClassNotFoundException ex) {             throw new RuntimeException(                     "Missing class when invoking static main " + className,                     ex);         }         //解析main方法         Method m;         try {             m = cl.getMethod("main", new Class[] { String[].class });         } catch (NoSuchMethodException ex) {             throw new RuntimeException(                     "Missing static main on " + className, ex);         } catch (SecurityException ex) {             throw new RuntimeException(                     "Problem getting static main on " + className, ex);         }           int modifiers = m.getModifiers();         if (! (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))) {             throw new RuntimeException(                     "Main method is not public and static on " + className);         }         //这里并没有直接去调用SystemServer.main()而是抛出了一个异常，这个异常将在//ZygoteInit.main()中被捕捉         throw new ZygoteInit.MethodAndArgsCaller(m, argv);     }

这里非常奇怪，invokeStaticMain并没有像我们想象的那样直接去调用SystemServer类的有关代码，它只是获取了SystemServer.main方法体和有关参数，并将其封装在一个MethodAndArgsCaller异常中，这个异常将在ZygoteInit.main中被捕捉。具体可以查看之前的代码。先查看一下这个异常类的设计，进入MethodAndArgsCaller类查看代码。

public static class MethodAndArgsCaller extends Exception             implements Runnable {         //调用方法体         private final Method mMethod;           //调用方法所需要的参数         private final String[] mArgs;           public MethodAndArgsCaller(Method method, String[] args) {             mMethod = method;             mArgs = args;         }           public void run() {             try {                 //最终还是调用了main()方法                 mMethod.invoke(null, new Object[] { mArgs });             } catch (IllegalAccessException ex) {                 throw new RuntimeException(ex);             } catch (InvocationTargetException ex) {                 Throwable cause = ex.getCause();                 if (cause instanceof RuntimeException) {                     throw (RuntimeException) cause;                 } else if (cause instanceof Error) {                     throw (Error) cause;                 }                 throw new RuntimeException(ex);             }         }     } }

抛出MethodAndArgsCaller异常分析：MethodAndArgsCaller异常是在startSystemSerer()中抛出的，从单个文件的代码来看，程序的执行流跳过runSelectLoop(..)。而runSelectLoop()是Zygote的服务的一个非常重要的方法。这显然不合理。考虑到startSystemServer中开启了名字为SystemServer的进程（此时，这个子进程程序流还未流入SystemServer.main()），抛出这个异常MethodAndArgsCaller的实际上是handleSystemServerProcess()的，即SystemServer进程，而父进程Zygote并未受影响。因此跳过runSelectLoop(..)是合理的。通过这样的方式，可以摆脱在启动初期时设置的堆栈桢。这些应该都和linux的fork机制有关。

以上SystemServer的启动流程大致时序如下图所示。

图4.  SystemServer启动大致时序

2.5   runSelectLoop()分析

在分析runSelectLoop之前，需要对应用程序的启动流程作一下简要的分析。应用程序的主入口是在ActivityThread的main函数，activity的startActivity最终是在ActivityManagerService中执行的。

首先调用的是ActivityManagerService.startProcessLocked()方法，这个方法有多个重载方法，但是都会调用Process.startViaZygote()，这个方法内部实际上是开启一个localSocket并连接Zygote进程（此时的Zygote正处于runSelectLoop之中监听事件）。建立连接之后首先是将参数通过localsocket对应的writer对象发送了所要启动APP的相关参数给Zygote，并等待localsocke对应的inputStream返回一个int型的pid。以及另一个boolean型的参数usingWrapper。

图5.  启动应用程序大致时序

之前已经描述，Zygote在建立ServerSystem服务之后一直处于runSelectLoop循环中，等待AMS的fork请求，runSelectLoop代码截取如下：

private static void runSelectLoop(String abiList) throws MethodAndArgsCaller {         ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();         ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();         FileDescriptor[] fdArray = new FileDescriptor[4];           fds.add(sServerSocket.getFileDescriptor());         peers.add(null);           int loopCount = GC_LOOP_COUNT;         while (true) {             int index;             if (loopCount <= 0) {                 gc();//在比较空闲的时候执行gc                 loopCount = GC_LOOP_COUNT;             } else {                 loopCount--;             }             try {                 fdArray = fds.toArray(fdArray);                 //这是一个Native方法，其方法内部调用了Select系统函数等待客户端连接请求                 index = selectReadable(fdArray);//注意这里的返回值和select()的返回值是不//同的概念,这里Index是活动fd的索引             } catch (IOException ex) {                 throw new RuntimeException("Error in select()", ex);             }             if (index < 0) {                 throw new RuntimeException("Error in select()");             } else if (index == 0) {//有连接进入，放入监听fd队列                 ZygoteConnection newPeer = acceptCommandPeer(abiList);                 peers.add(newPeer);                 fds.add(newPeer.getFileDescriptor());             } else {//有请求                 boolean done;                 done = peers.get(index).runOnce();//处理请求                   if (done) {                     peers.remove(index);                     fds.remove(index);                 }             }         }     }

进入runOnce()

boolean runOnce() throws ZygoteInit.MethodAndArgsCaller {           String args[];         Arguments parsedArgs = null;         FileDescriptor[] descriptors;           long startTime = SystemClock.elapsedRealtime();           try {             args = readArgumentList();//读取传递进来的请求参数             descriptors = mSocket.getAncillaryFileDescriptors();         }……            ……//fork出应用进程             pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,                     parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,                     parsedArgs.niceName, fdsToClose, parsedArgs.instructionSet,                     parsedArgs.appDataDir);            ……         try {             if (pid == 0) {                 // 子进程中                 IoUtils.closeQuietly(serverPipeFd);                 serverPipeFd = null;                 handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);                 return true;             } else {                 // 父进程中                 IoUtils.closeQuietly(childPipeFd);                 childPipeFd = null;                 //发送pid和usingWrapper给AMS                 return handleParentProc(pid, descriptors, serverPipeFd, parsedArgs);             }         } finally {             IoUtils.closeQuietly(childPipeFd);             IoUtils.closeQuietly(serverPipeFd);         }     }

进入handleChildProc()

private void handleChildProc(Arguments parsedArgs,             FileDescriptor[] descriptors, FileDescriptor pipeFd, PrintStream newStderr)             throws ZygoteInit.MethodAndArgsCaller {           closeSocket();         ZygoteInit.closeServerSocket();          ……         if (parsedArgs.niceName != null) {//设置进程名字             Process.setArgV0(parsedArgs.niceName);         }         //参数中配置了RuntimeInit,这里为true         if (parsedArgs.runtimeInit) {             if (parsedArgs.invokeWith != null) {//Android中另一种可能的启动方式                 WrapperInit.execApplication(parsedArgs.invokeWith,                         parsedArgs.niceName, parsedArgs.targetSdkVersion,                         pipeFd, parsedArgs.remainingArgs);             } else {//程序最终会走到这里                 RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion,                         parsedArgs.remainingArgs, null);             }         } else {            ……         }     }

可看到，handleChildProc最终调用RuntimeInit.ZygoteInit()。这个方法在分析SystemServer启动过程时已经分析过了，它依次调用了redirectLogStreams()、commonInit()、zygoteInitNative()  applicationInit()并最终调用了invokeStaticMain()抛出异常，在catch块中运行指定类的main函数。

 

3        分析与总结

本文主要分析了Android5.0中Zygote的启动，以及Zygote孵化SystemServer进程和普通应用进程的过程。从以上的分析可以得知，Android充分利用了Linux的一些特性，在保证了内存被尽可能地共享的同时，又保证了系统的性能和速度

原文地址： http://blog.csdn.net/a34140974/article/details/49783781