Zygote

相关源码：

/frameworks/base/cmds/app_process/App_main.cpp （内含AppRuntime类）
/frameworks/base/core/jni/AndroidRuntime.cpp
/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
/frameworks/base/core/java/com/android/internal/os/Zygote.java
/frameworks/base/core/java/android/net/LocalServerSocket.java

         

         在Android中，zygote是整个系统创建新进程的核心进程。zygote进程在内部会先启动Dalvik虚拟机，继而加载一些必要的系统资源和系统类，最后进入一种监听状态。

         在之后的运作中，当其他系统模块（比如AMS）希望创建新进程时，只需向zygote进程发出请求，zygote进程监听到该请求后，会相应地fork出新的进程，于是这个新进程在初生之时，就先天具有了自己的Dalvik虚拟机以及系统资源。

         zygote进程是由init进程启动起来，由init.rc 脚本中关于zygote的描述可知：zygote对应的可执行文件就是/system/bin/app_process，也就是说系统启动时会执行到这个可执行文件的main()函数里。

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作为一个名字标识了这个service（可执行程序）；

/system/bin/app_process表示可执行文件的位置；

class、user、group、onrestart这些关键字所对应的行都被称为options, options是用来描述的service一些特点，不同的service有着不同的options。

第三行表示在Zygote启动过程中，要在其内部创建一个名为zygote的socket，它在Linux下的权限是666，即所有用户多可以对它进行读写。

       下面看一个Zygote的启动流程图：

一、Zygote启动函数调用类的栈关系：
App_main.main
      AndroidRuntime.start
           startVm
           startReg
           ZygoteInit.main
                 registerZygoteSocket
                 preload
                 startSystemServer
                 runSelectLoop

       zygote服务的main()函数位于frameworks\base\cmds\app_process\App_main.cpp。关键代码如下：

int main(int argc, char* const argv[])
{
    . . . . . .
    AppRuntime runtime;
    const char* argv0 = argv[0];    // -Xzygote
    argc--;
    argv++;
    . . . . . .
    int i = runtime.addVmArguments(argc, argv);
    . . . . . .
    while (i < argc) {
        const char* arg = argv[i++];		// 应该是/system/bin目录
        if (!parentDir) {
            parentDir = arg;
        } else if (strcmp(arg, "--zygote") == 0) {
            zygote = true;
            niceName = "zygote";
        } else if (strcmp(arg, "--start-system-server") == 0) {
            startSystemServer = true;
        } 
        . . . . . .
    }

    if (niceName && *niceName) {
        setArgv0(argv0, niceName);
        set_process_name(niceName);     // 一般改名为“zygote”
    }
    runtime.mParentDir = parentDir;
    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;
   }
}

   

       main()函数里先构造了一个AppRuntime对象，即AppRuntime runtime；而后把进程名改成“zygote”，并利用runtime对象，把工作转交给java层的相应的***Init类处理。

      根据传入参数的不同可以有两种启动方式，一个是 "com.android.internal.os.RuntimeInit", 另一个是 ”com.android.internal.os.ZygoteInit", 对应RuntimeInit 和 ZygoteInit 两个类， 这两个类的主要区别在于Java端，可以明显看出，ZygoteInit 相比 RuntimeInit 多做了很多事情，比如说 “preload", "gc" 等等。但是在Native端，他们都做了相同的事， startVM() 和 startReg() 

简单地说就是：Zygote进程的main()函数在启动Dalvik虚拟机后，会调用另一个ZygoteInit类的main()静态函数。

1、 zygote在native层的调用示意图如下：

2、 zygote在java层的调用主要是由ZygoteInit.java完成的，调用示意图如下：

   ZygoteInit.java关键代码如下（frameworks/base/core/java/com/android/internal/os/ZygoteInit.java）

public class ZygoteInit {
	......

	public static void main(String argv[]) {
		try {
			......

			registerZygoteSocket();
			
			......

			......

			if (argv[1].equals("true")) {
				startSystemServer();
			} else if (!argv[1].equals("false")) {
				......
			}

			......

			if (ZYGOTE_FORK_MODE) {
				......
			} else {
				runSelectLoopMode();
			}

			......
		} catch (MethodAndArgsCaller caller) {
			......
		} catch (RuntimeException ex) {
			......
		}
	}

	......
}

主要做了四件事情：

（1）调用registerZygoteSocket函数创建了一个socket接口，用来和ActivityManagerService等通讯；

（2）预加载一些类与资源；

（3）调用startSystemServer函数来启动SystemServer组件；

         startSystemServer()并不是在函数体内直接调用Java类的main()函数的，而是通过抛异常的方式，在startSystemServer()之外加以处理的。

【为什么要以异常方式启动】

（a）首先、我们要先清楚，抛异常这一操作会引发什么？ 

       我们知道，当一个函数抛出异常后，这个异常会依次传递给调用它的函数，知道这个异常被捕获，如果这个异常一直没有被处理，最终就会引起程序的崩溃。

（b）其次、在传递异常的时候，应用程序的栈发生了什么变化？ 

        这就要牵涉到函数的执行模型了，我们知道，程序都是有一个个函数组成的(除了汇编程序)，c/c++/java/..等高级语言编写的应用程序，在执行的时候，他们都拥有自己的栈空间（是一种先进后出的内存区域），用于存放函数的返回地址和函数的临时数据，每调用一个函数时，就会把函数的返回地址和相关数据压入栈中，当一个函数执行完后，就会从栈中弹出，cpu会根据函数的返回地址，执行上一个调用函数的下一条指令。 

        所以，在抛出异常后，如果异常没有在当前的函数中捕获，那么当前的函数执行就会异常的退出，从应用程序的栈弹出，并将这个异常传递给上一个函数，直到异常被捕获处理，否则，就会引起程序的崩溃。

       因此，这里通过抛异常的方式启动主要是清理应用程序栈中ZygoteInit.main以上的函数栈帧，以实现当相应的main函数退出时，能直接退出整个应用程序。 当当前的main退出后，就会退回到MethodAndArgsCaller.run而这个函数直接就退回到ZygoteInit.main函数，而ZygoteInit.main也无其他的操作，直接退出了函数，这样整个应用程序将会完全退出。

（4）调用runSelectLoopMode函数进入一个无限循环在前面创建的socket接口上等待ActivityManagerService等的请求。

2.1 startSystemServer()

       其并不是在函数体内直接调用Java类的main()函数的，而是通过抛异常的方式，在startSystemServer()之外加以处理的。

private static boolean startSystemServer()
        throws MethodAndArgsCaller, RuntimeException 
{
    . . . . . .
    /* Hardcoded command line to start the system server */
    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",
        "--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);

        // fork出系统服务对应的进程
        pid = Zygote.forkSystemServer(parsedArgs.uid, parsedArgs.gid,
                                            parsedArgs.gids, parsedArgs.debugFlags, null,
                                            parsedArgs.permittedCapabilities,
                                            parsedArgs.effectiveCapabilities);
    } catch (IllegalArgumentException ex) {
        throw new RuntimeException(ex);
    }

    // 对新fork出的系统进程，执行handleSystemServerProcess()
    if (pid == 0) {
        handleSystemServerProcess(parsedArgs);
    }
    return true;
}

其中：

（1）Zygote.forkSystemServer()会通过jni调用linux的fork函数；

（2）startSystemServer()会在新fork出的子进程中调用handleSystemServerProgress()，进而抛出异常MethodAndArgsCaller，通过caller.run()启动com.android.server.SystemServer的main 方法。

可参考：Systemserver

2.2、runSelectLoop()

private static void runSelectLoop() 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();
            loopCount = GC_LOOP_COUNT;
        } else {
            loopCount--;
        }

        try {
            fdArray = fds.toArray(fdArray);
            index = selectReadable(fdArray);
        } catch (IOException ex) {
            throw new RuntimeException("Error in select()", ex);
        }

        if (index < 0) {
            throw new RuntimeException("Error in select()");
        } else if (index == 0) {
            ZygoteConnection newPeer = acceptCommandPeer();
            peers.add(newPeer);
            fds.add(newPeer.getFileDesciptor());
        } else {
            boolean done;
            done = peers.get(index).runOnce();
            if (done) {
                peers.remove(index);
                fds.remove(index);
            }
        }
    }
}

2.2.1、在一个while循环中，不断调用selectReadable()。

selectReadable函数是个native函数，主要就是调用select()而已。在Linux的socket编程中，select()负责监视若干文件描述符的变化情况。内部调用select等待客户端 的连接，客户端连接上之后就会返回。
返回值：
<0: 内部发生错误
=0: 该客户端第一次连接到服务端。服务端调用accept与客户 端建立连接。客户端在zygote中以ZygoteConnection对象表示。
>0: 客户端与服务端已经建立连接，并开始发送数据。表明发送数据的客户端的index，peers.get(index)取得 发送数据客户端的ZygoteConnection对象，之后调用runOnce 函数处理具体的请求。

2.2.2、runOnce()

boolean runOnce( ) {
       Arguments parsedArgs = null;
       FileDescriptor[] descriptors;

       //Reads one start command from the command socket.
       args = readArgumentList();
       descriptors = mSocket.getAncillaryFileDescriptors();

       //创建/Forks a new VM instance /process.
       //使用Jni 调用nativeFork
       pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid,
              parsedArgs.gids, parsedArgs.debugFlags, rlimits);

       //返回两次
       if (pid == 0) {
              // in child    
              serverPipeFd = null;
              handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);

              // should never get here, the child is expected to either
              return true;
       } else {

              // in parent...pid of < 0 means failure
              childPipeFd = null;
              return handleParentProc(pid, descriptors, serverPipeFd, parsedArgs);
       }
}

        从上面的代码中可以看到创建进程之后返回：
子进程：handleChildProc
父进程：handleParentProc
        我们关心的是子进程的执行，继续到handleChildProc中。

// Handles post-fork setup of child proc
private void handleChildProc(Arguments parsedArgs,...){
       ……
       if (parsedArgs.runtimeInit) {
           if (parsedArgs.invokeWith != null) {
　　　　　　　　//通过系统调用执行进程
　　　　　　　　WrapperInit.execApplication(parsedArgs.invokeWith,
　　　　　　　　　　parsedArgs.niceName, parsedArgs.targetSdkVersion,
　　　　　　　　　　pipeFd, parsedArgs.remainingArgs);

           } else {
　　　　　　　　//通过寻找到相应目标类的main()函数并执行
　　　　　　　　RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion,
　　　　　　　　　　parsedArgs.remainingArgs);
           }
       }
       ……
}

看到子进程的执行有两种方式：
　　WrapperInit.execApplication和RuntimeInit.zygoteInit

1）通过系统调用的方式执行进程 WrapperInit.execApplication：

public static void execApplication(……) {
　　……
　　Zygote.execShell(command.toString());
}

public static void execShell(String command) {
　　// using the exec() system call
　　nativeExecShell(command);
}

2）通过寻找到相应目标类的main()函数并执行 RuntimeInit.zygoteInit：

// The main function called when started through the zygote process.
public static final void zygoteInit( ){
zygoteInitNative();
applicationInit(targetSdkVersion, argv);
}

private static void applicationInit( ) {
// Remaining arguments are passed to the start class's static main
invokeStaticMain(args.startClass, args.startArgs);
}

通过RuntimeInit调用startClass的main函数，进而以异常的方式启动新的进程。

 static void invokeStaticMain(ClassLoader loader,
            String className, String[] argv)
            throws ZygoteInit.MethodAndArgsCaller {
    ....
        /*
         * This throw gets caught in ZygoteInit.main(), which responds
         * by invoking the exception's run() method. This arrangement
         * clears up all the stack frames that were required in setting
         * up the process.
         */
        throw new ZygoteInit.MethodAndArgsCaller(m, argv);
    }