Android5.0源码分析—— Zygote进程分析
2015-11-11 17:01
597 查看
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; |
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 |
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 { …… } } |
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); …… } } ……//回收资源关闭虚拟机等操作,这个函数除非进程退出,否则不会返回 } |
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; } } |
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; } |
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); } //永远不会执行到这里 } |
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); } |
private static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) throws ZygoteInit.MethodAndArgsCaller{ nativeSetExitWithoutCleanup(true); …… invokeStaticMain(args.startClass, args.startArgs, classLoader); } |
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); } |
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); } } } } |
以上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); } } } } |
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); } } |
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 { …… } } |
3 分析与总结
本文主要分析了Android5.0中Zygote的启动,以及Zygote孵化SystemServer进程和普通应用进程的过程。从以上的分析可以得知,Android充分利用了Linux的一些特性,在保证了内存被尽可能地共享的同时,又保证了系统的性能和速度。相关文章推荐
- android中tabhost学习
- android开发入门经验 ADT Bundle环境搭建
- Android Matrix
- AndroidStudio的启动参数简介
- QT创建Android下的lib时出现的编译错误
- Android sqlite数据库升级表字段
- Android快速SDK说明
- [Android] Otto源码简析
- android监听应用安装,如判断是新安装的应用,还是覆盖安装的应用
- Android——分别获取导航栏、状态栏高度
- Android 自定义字体
- Android开源项目(类库+控件)
- Android 启动多个闹钟。
- ionic 中遇到的一些东西
- 关于 Android 5.0 无法安装应用问题
- [置顶] android高性能编程中需要注意的问题
- Android编程之监听器的实现方法
- [置顶] android实现的文件上传案例探讨
- Android中Service类onStartCommand的返回值问题
- android中控件的使用