目录

1、Zygote简介

2、Zygote进程如何启动

  2.1 init.zygote64_32.rc文件

  2.2 查看ps信息

  2.3 启动

3、Zygote作用

  3.1 启动system_server

  3.2 查看与验证Zygote启动systemserver

  3.3 Zygote启动其他子进程

4、总结

1、Zygote简介

  • 1.1 系统启动流程

    • 从按下电源到看到launcher,手机的启动是一个非常复杂的过程。

      bootloader是手机上电之后第一个运行的程序,其作用是硬件的初始化,其作用类似于PC机的bios。

      bootloader完成其工作后,将 Linux kernel镜像拷贝到内存中。完成剩余的与硬件平台相关的初始化工作,比如文件系统,驱动模块。最后启动第一个用户进程-init 进程并等待用户进程的执行。

      用户空间的第一个进程init

  • 1.2 zygote理解
    • 在Android系统中,所有的应用程序进程以及系统服务进程SystemServer都是由Zygote进程孕育(fork)出来的。由于Zygote进程在Android系统中有着如此重要的地位,本文将详细分析它的启动过程。---老罗
    • android系统中创建java世界的盘古  创建新进程的女娲。 ---邓凡平

2、Zygote进程如何启动

  • 2.1 init.zygote64_32.rc文件

    • system/core/rootdir/init.zygote64_32.rc文件内容
    •  1 service zygote /system/bin/app_process32 -Xzygote /system/bin --zygote --start-system-server --socket-name=zygote
      2 class main
      3 socket zygote stream 660 root system
      4 onrestart write /sys/android_power/request_state wake
      5 onrestart write /sys/power/state on
      6 onrestart restart media
      7 onrestart restart netd
      8
      9 service zygote_secondary /system/bin/app_process64 -Xzygote /system/bin --zygote --socket-name=zygote_secondary
      10 class main
      11 socket zygote_secondary stream 660 root system
      12 onrestart restart zygote
  • 2.2 查看ps信息
    • Zygote64、Zygote是在init.rc中定义的服务进程,由init进程启动,PPID均为1。其中比较关键的vold、rild、surfaceflinger等关键进程也都是通过init进程启动的。

    • LOCAL_MULTILIB: Android.mk中用来设置编译为32位或者64位的apk,so等

  • 2.3 启动
    • Zygote process main(frameworks/base/cmds/app_process/app_main.cpp)
    •   1 int main(int argc, char* const argv[])
      2 {
      3 ...
      121 if (zygote) {
      122 runtime.start("com.android.internal.os.ZygoteInit", args);
      123 } else if (className) {
      124 runtime.start("com.android.internal.os.RuntimeInit", args);
      125 } else {
      126 fprintf(stderr, "Error: no class name or --zygote supplied.\n");
      127 app_usage();
      128 LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
      129 return 10;
      130 }
      131 }
    • 将init.rc中指定的-Xzygote参数传给JVM
      将进程的名字改为zygote(可以回答前面的问题)
      执行AppRuntime类的start()方法,runtime.start(“com.android.internal.os.ZygoteInit”, true);
    •   1 void AndroidRuntime::start(const char* className, const Vector<String8>& options)
      2 {
      3 ...
      30 //const char* kernelHack = getenv("LD_ASSUME_KERNEL");
      31 //ALOGD("Found LD_ASSUME_KERNEL='%s'\n", kernelHack);
      32
      33 /* start the virtual machine */
      34 JniInvocation jni_invocation;
      35 jni_invocation.Init(NULL);
      36 JNIEnv* env;
      37 if (startVm(&mJavaVM, &env) != 0) {
      38 return;
      39 }
      40 onVmCreated(env);
      41
      42 /*
      43 * Register android functions.
      44 */
      45 if (startReg(env) < 0) {
      46 ALOGE("Unable to register all android natives\n");
      47 return;
      48 }
      49
      50 /*
      51 * We want to call main() with a String array with arguments in it.
      52 * At present we have two arguments, the class name and an option string.
      53 * Create an array to hold them.
      54 */
      55 jclass stringClass;
      56 jobjectArray strArray;
      57 jstring classNameStr;
      58
      59 stringClass = env->FindClass("java/lang/String");
      60 assert(stringClass != NULL);
      61 strArray = env->NewObjectArray(options.size() + 1, stringClass, NULL);
      62 assert(strArray != NULL);
      63 classNameStr = env->NewStringUTF(className);
      64 assert(classNameStr != NULL);
      65 env->SetObjectArrayElement(strArray, 0, classNameStr);
      66
      67 for (size_t i = 0; i < options.size(); ++i) {
      68 jstring optionsStr = env->NewStringUTF(options.itemAt(i).string());
      69 assert(optionsStr != NULL);
      70 env->SetObjectArrayElement(strArray, i + 1, optionsStr);
      71 }
      72
      73 /*
      74 * Start VM. This thread becomes the main thread of the VM, and will
      75 * not return until the VM exits.
      76 */
      77 char* slashClassName = toSlashClassName(className);
      78 jclass startClass = env->FindClass(slashClassName);
      79 if (startClass == NULL) {
      80 ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
      81 /* keep going */
      82 } else {
      83 jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
      84 "([Ljava/lang/String;)V");
      85 if (startMeth == NULL) {
      86 ALOGE("JavaVM unable to find main() in '%s'\n", className);
      87 /* keep going */
      88 } else {
      89 env->CallStaticVoidMethod(startClass, startMeth, strArray);
      90
      91 #if 0
      92 if (env->ExceptionCheck())
      93 threadExitUncaughtException(env);
      94 #endif
      95 }
      96 }
      97 free(slashClassName);
      98
      99 ALOGD("Shutting down VM\n");
      100 if (mJavaVM->DetachCurrentThread() != JNI_OK)
      101 ALOGW("Warning: unable to detach main thread\n");
      102 if (mJavaVM->DestroyJavaVM() != 0)
      103 ALOGW("Warning: VM did not shut down cleanly\n");
      104 }
    • runtime.start函数,即在frameworks\base\core\jni\AndroidRuntime.cpp文件中
      • AndroidRuntime::startVm()中,设置一些虚拟机的参数后,通过JNI_CreateJavaVM()启动虚拟机。
      • StartReg()注册JNI 函数
      • env->CallStaticVoidMethod,调用ZygoteInit类的main()方法,正式进入到Java世界.
    • frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
    • public static void main(String argv[]) {
      try {
      ....
      registerZygoteSocket(socketName);
      EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,
      SystemClock.uptimeMillis());
      preload();
      EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,
      SystemClock.uptimeMillis()); // Finish profiling the zygote initialization.
      SamplingProfilerIntegration.writeZygoteSnapshot(); // Do an initial gc to clean up after startup
      gc(); // Disable tracing so that forked processes do not inherit stale tracing tags from
      // Zygote.
      Trace.setTracingEnabled(false); if (startSystemServer) {
      startSystemServer(abiList, socketName);
      } Log.i(TAG, "Accepting command socket connections");
      runSelectLoop(abiList); closeServerSocket();
      } catch (MethodAndArgsCaller caller) {
      caller.run();
      } catch (RuntimeException ex) {
      Log.e(TAG, "Zygote died with exception", ex);
      closeServerSocket();
      throw ex;
      }
      }
    • registerZygoteSocket,创建Socket服务端对象sServerSocket

      preload方法预加载类,资源等

      调用startSystemServer方法启动系统服务system_server

      runSelectLoopMode监听和处理sServerSocket的Socket请求

  • 3、Zygote作用
    • 3.1 启动system_server

      •  1 /**
        2 * Prepare the arguments and fork for the system server process.
        3 */
        4 private static boolean startSystemServer(String abiList, String socketName)
        5 throws MethodAndArgsCaller, RuntimeException {
        6 ...
        31 int pid;
        32
        33 try {
        34 parsedArgs = new ZygoteConnection.Arguments(args);
        35 ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
        36 ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);
        37
        38 /* Request to fork the system server process */
        39 pid = Zygote.forkSystemServer(
        40 parsedArgs.uid, parsedArgs.gid,
        41 parsedArgs.gids,
        42 parsedArgs.debugFlags,
        43 null,
        44 parsedArgs.permittedCapabilities,
        45 parsedArgs.effectiveCapabilities);
        46 } catch (IllegalArgumentException ex) {
        47 throw new RuntimeException(ex);
        48 }
        49
        50 /* For child process */
        51 if (pid == 0) {//子进程进入
        52 if (hasSecondZygote(abiList)) {
        53 waitForSecondaryZygote(socketName);
        54 }
        55
        56 handleSystemServerProcess(parsedArgs);
        57 }
        58
        59 return true;
        60 }
      • forkSystemServer,调用Native方法fork子进程
        通过forkSystemServer方法返回的值,进入两个分支处理:父进程返回子进程pid值,进入到ZygoteInit类中的main方法继续处理;而子进程调用handleSystemServerProcess方法,最终会运行system_server。
      •  1 /**
        2 * Finish remaining work for the newly forked system server process.
        3 */
        4 private static void handleSystemServerProcess(
        5 ZygoteConnection.Arguments parsedArgs)
        6 throws ZygoteInit.MethodAndArgsCaller {
        7
        8 closeServerSocket();//子进程已经不是服务器了,所以关掉。
        9
        10 // set umask to 0077 so new files and directories will default to owner-only permissions.
        11 Os.umask(S_IRWXG | S_IRWXO);
        12
        13 if (parsedArgs.niceName != null) {
        14 Process.setArgV0(parsedArgs.niceName);
        15 }
        16
        17 final String systemServerClasspath = Os.getenv("SYSTEMSERVERCLASSPATH");
        18 if (systemServerClasspath != null) {
        19 performSystemServerDexOpt(systemServerClasspath);
        20 }
        21
        22 if (parsedArgs.invokeWith != null) {
        23 String[] args = parsedArgs.remainingArgs;
        24 // If we have a non-null system server class path, we'll have to duplicate the
        25 // existing arguments and append the classpath to it. ART will handle the classpath
        26 // correctly when we exec a new process.
        27 if (systemServerClasspath != null) {
        28 String[] amendedArgs = new String[args.length + 2];
        29 amendedArgs[0] = "-cp";
        30 amendedArgs[1] = systemServerClasspath;
        31 System.arraycopy(parsedArgs.remainingArgs, 0, amendedArgs, 2, parsedArgs.remainingArgs.length);
        32 }
        33
        34 WrapperInit.execApplication(parsedArgs.invokeWith,
        35 parsedArgs.niceName, parsedArgs.targetSdkVersion,
        36 null, args);
        37 } else {
        38 ClassLoader cl = null;
        39 if (systemServerClasspath != null) {
        40 cl = new PathClassLoader(systemServerClasspath, ClassLoader.getSystemClassLoader());
        41 Thread.currentThread().setContextClassLoader(cl);
        42 }
        43
        44 /*
        45 * Pass the remaining arguments to SystemServer.
        46 */
        47 RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
        48 }
        49
        50 /* should never reach here */
        51 }
      • frameworks/base/core/java/com/android/internal/os/RuntimeInit.java
      • 43 public class RuntimeInit {
        44 。。。
        197 private static void invokeStaticMain(String className, String[] argv, ClassLoader classLoader)
        198 throws ZygoteInit.MethodAndArgsCaller {
        199 。。。
        232 throw new ZygoteInit.MethodAndArgsCaller(m, argv);
        233 }
        267 public static final void zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
        268 throws ZygoteInit.MethodAndArgsCaller {
        269 if (DEBUG) Slog.d(TAG, "RuntimeInit: Starting application from zygote");
        270
        271 redirectLogStreams();
        272
        273 commonInit();
        274 nativeZygoteInit();
        275
        276 applicationInit(targetSdkVersion, argv, classLoader);
        277 }
        297 private static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
        298 throws ZygoteInit.MethodAndArgsCaller {
        299 。。。
        308 VMRuntime.getRuntime().setTargetHeapUtilization(0.75f);
        309 VMRuntime.getRuntime().setTargetSdkVersion(targetSdkVersion);
        310
        311 。。。
        320 // Remaining arguments are passed to the start class's static main
        321 invokeStaticMain(args.startClass, args.startArgs, classLoader);
        322 }
        363 public static final IBinder getApplicationObject() {
        364 return mApplicationObject;
        365 }
        425 }
      •  1 public static void main(String argv[]) {
        2 try {
        3 。。。
        42 if (startSystemServer) {
        43 startSystemServer(abiList, socketName);
        44 }
        45 。。。//然而并没有机会进入循环
        50 } catch (MethodAndArgsCaller caller) {
        51 caller.run();
        52 } catch (RuntimeException ex) {
        53 Log.e(TAG, "Zygote died with exception", ex);
        54 closeServerSocket();
        55 throw ex;
        56 }
        57 }
      • 这个函数会执行两个操作,一个是调用zygoteInitNative函数来执行一个Binder进程间通信机制的初始化工作,这个工作完成之后,这个进 程中的Binder对象就可以方便地进行进程间通信了,另一个是调用上面传进来的com.android.server.SystemServer类的main函数。
    • 3.2 查看与验证Zygote启动systemserver
      • ps进程信息,验证system_server是Zygote的分裂出的第一个子进程.
    • 3.3 Zygote启动其他子进程
      • 注意:重复的不再涉及,我们只是分析一下7-12吧。
      • frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
      •  1 /**
        2 * Runs the zygote process's select loop. Accepts new connections as
        3 * they happen, and reads commands from connections one spawn-request's
        4 * worth at a time.
        5 *
        6 * @throws MethodAndArgsCaller in a child process when a main() should
        7 * be executed.
        8 */
        9 private static void runSelectLoop(String abiList) throws MethodAndArgsCaller {
        10 。。。
        18 while (true) {
        19 。。。
        38 try {
        39 fdArray = fds.toArray(fdArray);
        40 index = selectReadable(fdArray);
        41 } catch (IOException ex) {
        42 throw new RuntimeException("Error in select()", ex);
        43 }
        44
        45 if (index < 0) {
        46 throw new RuntimeException("Error in select()");
        47 } else if (index == 0) {
        48 ZygoteConnection newPeer = acceptCommandPeer(abiList);
        49 peers.add(newPeer);
        50 fds.add(newPeer.getFileDescriptor());
        51 } else {
        52 boolean done;
        53 done = peers.get(index).runOnce();
        54
        55 if (done) {
        56 peers.remove(index);
        57 fds.remove(index);
        58 }
        59 }
        60 }
        61 }
      • runSelectLoopMode中while(true)循环,接收到Socket请求后,会fork出子进程,子进程调用handleChildProc方法,最终抛出RuntimeInit.invokeStaticMain异常,退出while(true)循环(与fork Systemserver不一样,后者没有进入循环),进入到android.app.ActivityThread类的main方法执行;父进程调用handleParentProc方法,再次进入runSelectLoopMode中while(true)循环,准备接收下一个的请求事件。
      • frameworks/base/core/java/com/android/internal/os/ZygoteConnection.java
      •   1 boolean runOnce() throws ZygoteInit.MethodAndArgsCaller {
           ...
        37 try {
        38 ...
        105 pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,
        106 parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,
        107 parsedArgs.niceName, fdsToClose, parsedArgs.instructionSet,
        108 parsedArgs.appDataDir);
        109 checkTime(startTime, "zygoteConnection.runOnce: postForkAndSpecialize");
        110 } catch (IOException ex) {
        111 logAndPrintError(newStderr, "Exception creating pipe", ex);
        112 } catch (ErrnoException ex) {
        113 logAndPrintError(newStderr, "Exception creating pipe", ex);
        114 } catch (IllegalArgumentException ex) {
        115 logAndPrintError(newStderr, "Invalid zygote arguments", ex);
        116 } catch (ZygoteSecurityException ex) {
        117 logAndPrintError(newStderr,
        118 "Zygote security policy prevents request: ", ex);
        119 }
        120
        121 try {
        122 if (pid == 0) {
        123 // in child
        124 IoUtils.closeQuietly(serverPipeFd);
        125 serverPipeFd = null;
        126 handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);
        127
        128 // should never get here, the child is expected to either
        129 // throw ZygoteInit.MethodAndArgsCaller or exec().
        130 return true;
        131 } else {
        132 // in parent...pid of < 0 means failure
        133 IoUtils.closeQuietly(childPipeFd);
        134 childPipeFd = null;
        135 return handleParentProc(pid, descriptors, serverPipeFd, parsedArgs);
        136 }
        137 } finally {
        138 IoUtils.closeQuietly(childPipeFd);
        139 IoUtils.closeQuietly(serverPipeFd);
        140 }
        141 }
      • 10和11略过,只是返回而已。我们现在进入子进程的handleChildProc。
      •  1 private void handleChildProc(Arguments parsedArgs,
        2 FileDescriptor[] descriptors, FileDescriptor pipeFd, PrintStream newStderr)
        3 throws ZygoteInit.MethodAndArgsCaller {
        4
        5 /**
        6 * By the time we get here, the native code has closed the two actual Zygote
        7 * socket connections, and substituted /dev/null in their place. The LocalSocket
        8 * objects still need to be closed properly.
        9 */
        10
        11 closeSocket();
        12 ZygoteInit.closeServerSocket();
        13
        14 。。。
        55 if (parsedArgs.invokeWith != null) {
        56 WrapperInit.execStandalone(parsedArgs.invokeWith,
        57 parsedArgs.classpath, className, mainArgs);
        58 } else {
        59 ClassLoader cloader;
        60 if (parsedArgs.classpath != null) {
        61 cloader = new PathClassLoader(parsedArgs.classpath,
        62 ClassLoader.getSystemClassLoader());
        63 } else {
        64 cloader = ClassLoader.getSystemClassLoader();
        65 }
        66
        67 try {
        68 ZygoteInit.invokeStaticMain(cloader, className, mainArgs);
        69 } catch (RuntimeException ex) {
        70 logAndPrintError(newStderr, "Error starting.", ex);
        71 }
        72 }
        73 。。。
        74 }
      • 剩余的就和上面雷同了,这里不再分析。

4、总结

  • 系统启动时init进程会创建Zygote进程,Zygote进程负责后续Android应用程序框架层的其它进程的创建和启动工作。(可以使用ps查看)

    Zygote进程会首先创建一个SystemServer进程,SystemServer进程负责启动系统的关键服务,如包管理服务PackageManagerService和应用程序组件管理服务ActivityManagerService。

    当我们需要启动一个Android应用程序时,ActivityManagerService会通过Socket进程间通信机制,通知Zygote进程为这个应用程序创建一个新的进程。

 

Zygote启动及其作用的更多相关文章

  1. Android系统进程Zygote启动过程的源代码分析

    文章转载至CSDN社区罗升阳的安卓之旅,原文地址:http://blog.csdn.net/luoshengyang/article/details/6768304 在Android系统中,所有的应用 ...

  2. Android 8.1 源码_启动篇(二) -- 深入研究 zygote(转 Android 9.0 分析)

    前言 在Android中,zygote是整个系统创建新进程的核心进程.zygote进程在内部会先启动Dalvik虚拟机,继而加载一些必要的系统资源和系统类,最后进入一种监听状态.在之后的运作中,当其他 ...

  3. Zygote及System进程启动

    1.  init 根据init.rc 运行 app_process, 并携带‘--zygote' 和 ’--startSystemServer' 参数. 2.  AndroidRuntime.cpp: ...

  4. Android Zygote进程启动分析

    dvm,app进程,linux进程三者关系 DVM指 dalivk 的虚拟机.每一个 Android 应用程序都在它自己的进程中运行,都拥有一个独立的 Dalvik 虚拟机实例.而每一个 DVM 都是 ...

  5. 图解Android - Zygote, System Server 启动分析

    Init 是所有Linux程序的起点,而Zygote于Android,正如它的英文意思,是所有java程序的'孵化池'(玩过星际虫族的兄弟都晓得的).用ps 输出可以看到 >adb shell ...

  6. 笔记:Zygote和SystemServer进程启动过程

    简述 Android设备启动过程中,先是Linux内核加载完,接着Android中的第一个进程init启动,它会启动一些需要开机启动的进程. Zygote就是进程init启动起来的.Android中所 ...

  7. Android系统启动流程(二)解析Zygote进程启动过程

    1.Zygote简介 在Android系统中,DVM(Dalvik虚拟机).应用程序进程以及运行系统的关键服务的SystemServer进程都是由Zygote进程来创建的,我们也将它称为孵化器.它通过 ...

  8. Zygote和System进程的启动过程

    ##init脚本的启动 +------------+ +-------+ +-----------+ |Linux Kernel+--> |init.rc+-> |app_process| ...

  9. Zygote和System进程的启动过程、Android应用进程启动过程

    1.基本过程 init脚本的启动Zygote Zygote进程的启动 System进程的启动 Android应用进程启动过程 2.init脚本的启动 +------------+ +-------+ ...

随机推荐

  1. MYSQL 存储引擎概述

    一.存储引擎 Mysql中的数据用各种不同的技术存储在文件(或者内存)中.这些技术中每一种技术都使用了不同的存储机制,索引技巧.锁定水平并且最终提供广泛的不同功能和能力.通过选择不同的技术,你能够获得 ...

  2. 腿部——哑铃&杠铃

  3. Linux在丢失的情况下重置密码

    1.开机菜单是 移动光标到第一行 --敲击e 2.找到UTF-8,加上空格rd.break,敲击ctrl+x 3.输入以下命令 mount -o remount,rw /sysroot chroot ...

  4. zabbix-web切换为nginx及https

    目录 zabbix-web切换为nginx及https 1.背景和环境 2.安装nginx 2.1.编译参数 2.2.修改配置文件并配置https 2.3.配置nginx为系统服务 3.安装php 3 ...

  5. centos 安装vsftp 服务

    安装软件yum install vsftpd -y 启动测试 # systemctl start vsftpd# netstat -nultp | grep 21tcp 0 0 0.0.0.0:21 ...

  6. 使用Arduino开发板制作交流电压表

    在本文中,我们将使用Arduino开发板制作一个交流电压测量装置,测量我们家中交流电源的电压.我们将在Arduino IDE的串行监视器上打印输出该电压,并在万用表上显示出来. 制作数字电压表比模拟电 ...

  7. 剑指Offer(三十五):数组中的逆序对

    剑指Offer(三十五):数组中的逆序对 搜索微信公众号:'AI-ming3526'或者'计算机视觉这件小事' 获取更多算法.机器学习干货 csdn:https://blog.csdn.net/bai ...

  8. Java精通并发-自旋对于synchronized关键字的底层意义与价值分析以及互斥锁属性详解与Monitor对象特性解说【纯理论】

    自旋对于synchronized关键字的底层意义与价值分析: 对于synchronized关键字的底层意义和价值分析,下面用纯理论的方式来对它进行阐述,自旋这个概念就会应运而生,还是很重要的,下面阐述 ...

  9. 从锅炉工到AI专家 ---- 系列教程

    TensorFlow从1到2(十二)生成对抗网络GAN和图片自动生成 那些令人惊艳的TensorFlow扩展包和社区贡献模型  从锅炉工到AI专家(11)(END) 从锅炉工到AI专家(10)  从锅 ...

  10. P1169 [ZJOI2007]棋盘制作[悬线法/二维dp]

    题目描述 国际象棋是世界上最古老的博弈游戏之一,和中国的围棋.象棋以及日本的将棋同享盛名.据说国际象棋起源于易经的思想,棋盘是一个8 \times 88×8大小的黑白相间的方阵,对应八八六十四卦,黑白 ...