Android 8.1 zygote创建新应用进程
涉及到的文件以及路径：
frameworks/base/core/java/com/android/internal/os/Zygote.java
frameworks/base/core/java/com/android/internal/os/ZygoteConnection.java
frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
frameworks/base/core/java/com/android/internal/os/ZygoteServer.java
分析过Android系统启动流程的同学都知道，zygote启动之后，会调用ZygoteInit.java中的main函数。
ZygoteInit.java的路径： frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
这个main函数如下：
public static void main(String argv[]) {
// 创建一个ZygoteServer 对象，这个是8.0 之后才有的
// 这个就是zygote最后等待ActivityManager 连接来 fork新进程的地方
ZygoteServer zygoteServer = new ZygoteServer();
// Mark zygote start. This ensures that thread creation will throw
// an error.
// 调用native函数，确保当前没有其它线程在运行
// 主要还是处于安全的考虑
// 启动无多线程模式 .当在zygoteInit中新建线程系统挂掉
// 主要是由于担心用户新建线程提高预加载速度
// 但是可能没做好同步工作, 当有的应用需要预加载的资源,但是多线程情况下还没有加载,发生问题
ZygoteHooks.startZygoteNoThreadCreation();
// Zygote goes into its own process group.
// 指定当前进程的id(第一个参数是目标进程id，第二个参数是进程组id，把第二个参数设置成第一个的值)
try {
Os.setpgid(0, 0);
} catch (ErrnoException ex) {
throw new RuntimeException("Failed to setpgid(0,0)", ex);
}
final Runnable caller;
try { // 解析上面传递过来的参数
// Report Zygote start time to tron unless it is a runtime restart
if (!"1".equals(SystemProperties.get("sys.boot_completed"))) { // 如果是重启sys.boot_completed值是1
//上报Zygote进程启动的时间
MetricsLogger.histogram(null, "boot_zygote_init",(int) SystemClock.elapsedRealtime());
}
String bootTimeTag = Process.is64Bit() ? "Zygote64Timing" : "Zygote32Timing";
TimingsTraceLog bootTimingsTraceLog = new TimingsTraceLog(bootTimeTag,Trace.TRACE_TAG_DALVIK);
bootTimingsTraceLog.traceBegin("ZygoteInit");
RuntimeInit.enableDdms();
boolean startSystemServer = false; // 是否启动 SystemServer
String socketName = "zygote"; // 创建的socket的名称
String abiList = null; // 支持的so库的类型
boolean enableLazyPreload = false; // 这个尚不清楚，不过传递过来的参数中没有这个
for (int i = 1; i < argv.length; i++) {
if ("start-system-server".equals(argv[i])) {
startSystemServer = true;
} else if ("--enable-lazy-preload".equals(argv[i])) {
enableLazyPreload = true;
} else if (argv[i].startsWith(ABI_LIST_ARG)) {
abiList = argv[i].substring(ABI_LIST_ARG.length());
} else if (argv[i].startsWith(SOCKET_NAME_ARG)) {
socketName = argv[i].substring(SOCKET_NAME_ARG.length());
} else {
throw new RuntimeException("Unknown command line argument: " + argv[i]);
}
}
if (abiList == null) {
throw new RuntimeException("No ABI list supplied.");
}
zygoteServer.registerServerSocket(socketName); // 注册server socket
// In some configurations, we avoid preloading resources and classes eagerly.
// In such cases, we will preload things prior to our first fork.
if (!enableLazyPreload) {
bootTimingsTraceLog.traceBegin("ZygotePreload");
EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,
SystemClock.uptimeMillis());
preload(bootTimingsTraceLog);
EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,
SystemClock.uptimeMillis());
bootTimingsTraceLog.traceEnd(); // ZygotePreload
} else {
Zygote.resetNicePriority();
}
// Do an initial gc to clean up after startup
bootTimingsTraceLog.traceBegin("PostZygoteInitGC");
gcAndFinalize();
bootTimingsTraceLog.traceEnd(); // PostZygoteInitGC
bootTimingsTraceLog.traceEnd(); // ZygoteInit
// Disable tracing so that forked processes do not inherit stale tracing tags from
// Zygote.
Trace.setTracingEnabled(false, 0);
// Zygote process unmounts root storage spaces.
// // 卸载root的存储空间
Zygote.nativeUnmountStorageOnInit();
// Set seccomp policy
// Set seccomp policy
// 加载seccomp的过滤规则
// 所有 Android 软件都使用系统调用（简称为 syscall）与 Linux 内核进行通信
// 内核提供许多特定于设备和SOC的系统调用，让用户空间进程（包括应用）可以直接与内核进行交互
// 不过，其中许多系统调用Android未予使用或未予正式支持
// 通过seccomp，Android可使应用软件无法访问未使用的内核系统调用
// 由于应用无法访问这些系统调用，因此，它们不会被潜在的有害应用利用
// 该过滤器安装到zygote进程中，由于所有Android应用均衍生自该进程
// 因而会影响到所有应用
Seccomp.setPolicy();
ZygoteHooks.stopZygoteNoThreadCreation(); // 允许有其他线程了
if (startSystemServer) {
Runnable r = forkSystemServer(abiList, socketName, zygoteServer); // 启动SystemServer
// {@code r == null} in the parent (zygote) process, and {@code r != null} in the
// child (system_server) process.
if (r != null) {
r.run(); // 这里会调用到 RuntimeInit.java 中的 MethodAndArgsCaller 的 run方法，来正式进入 SystemServer的main函数
return;
}
}
Log.i(TAG, "Accepting command socket connections");
// The select loop returns early in the child process after a fork and
// loops forever in the zygote.
caller = zygoteServer.runSelectLoop(abiList); // zygote进程进入无限循环，处理请求
} catch (Throwable ex) {
Log.e(TAG, "System zygote died with exception", ex);
throw ex;
} finally {
Log.i(TAG, "zygoteServer.closeServerSocket finally finally");
// 这个地方有两个调用的流程
// 1: zygote 进程退出的时候会调用这个函数，用来关闭zygote自己创建的用来接收ActivityManager的链接请求的socket
// 2：当每个子线程fork完毕，准备好之后，会走到这里，这个时候会在子进程中执行的，这里会调用closeServerSocket函数，确保从zygote集成过来的socket关闭。
// 其实这个时候，因为子进程刚刚fock出来的时候就已经掉用过closeServerSocket函数了，因此再次调用，是没有效果的
zygoteServer.closeServerSocket();
}
// We're in the child process and have exited the select loop. Proceed to execute the
// command.
if (caller != null) {
caller.run(); // 这里才是重点，上面会返回一个Runnable的对象，这个地方调用他的 run函数会进入到子进程的真正的main函数里面
}
}这个main函数中，首选会创建一个ZygoteServer对象，这个就是用来处理后续zygote socket连接的地方。然后会解析前面传递进来的参数。根据参数决定是否启动SystemServer，启动SystemServer的部分，网上比较多，这里就不做详细介绍了。
根据代码流程我们会发现，在main函数的最后会调用 caller = zygoteServer.runSelectLoop(abiList);进入到ZygoteServer类的runSelectLoop函数中。下面我们就着重分析下这个函数的具体实现。
/**
* Runs the zygote process's select loop. Accepts new connections as
* they happen, and reads commands from connections one spawn-request's
* worth at a time.
*/
Runnable runSelectLoop(String abiList) {
// 记录需要监听的句柄
ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
// 记录上面监听的句柄所对应的处理类的实例对象
ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
fds.add(mServerSocket.getFileDescriptor());
peers.add(null); // 这里add null 是为了使得它的index 和 fds 的index想对应。
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;
}
Slog.e(TAG, "runSelectLoop i = "+i+" mIsForkChild = "+mIsForkChild);
if (i == 0) { // 如果 i是0，就说明监听到了连接请求，
// 此时调用 acceptCommandPeer 函数，这个函数会调用 mServerSocket.accept() 接受连接，并返回句柄
// 然后用此句柄为参数创建了 ZygoteConnection 对象，然后由 ZygoteConnection 对象负责这一个连接的后续数据处理
ZygoteConnection newPeer = acceptCommandPeer(abiList);
peers.add(newPeer); // 添加到 peers 这个
fds.add(newPeer.getFileDesciptor()); // 添加到 fds，然后在下次循环的时候，将刚刚接受的链接请求也一同添加到监听
} else { // 如果不是0.那就是上面 i=0的时候接受到的连接发来数据了。
try {
ZygoteConnection connection = peers.get(i); // 从刚刚记录的peers中获取处理对应数据的 ZygoteConnection 类
final Runnable command = connection.processOneCommand(this);
// 因为上面的 processOneCommand 函数调用中，如果创建了新的进程，上面的函数就会有两个返回，
// 第一个是父进程的正常返回 此时的返回值是 null，还是在zygote进程中运行，并且mIsForkChild的值是没有变的，这个时候会进入到else中
// 第二个返回时子进程的返回 此时的返回时不是空，此时是在子进程中运行，并且在子进程刚刚创建的时候，就将自己的mIsForkChild设置为 true了。
if (mIsForkChild) {
// We're in the child. We should always have a command to run at this
// stage if processOneCommand hasn't called "exec".
// 这里是在子进程
if (command == null) {
throw new IllegalStateException("command == null");
}
return command;
} else {
// We're in the server - we should never have any commands to run.
// 这里是在父进程中
if (command != null) {
throw new IllegalStateException("command != null");
}
// We don't know whether the remote side of the socket was closed or
// not until we attempt to read from it from processOneCommand. This shows up as
// a regular POLLIN event in our regular processing loop.
if (connection.isClosedByPeer()) {
connection.closeSocket();
peers.remove(i);
fds.remove(i);
}
}
} catch (Exception e) {
if (!mIsForkChild) {
// We're in the server so any exception here is one that has taken place
// pre-fork while processing commands or reading / writing from the
// control socket. Make a loud noise about any such exceptions so that
// we know exactly what failed and why.
Slog.e(TAG, "Exception executing zygote command: ", e);
// Make sure the socket is closed so that the other end knows immediately
// that something has gone wrong and doesn't time out waiting for a
// response.
ZygoteConnection conn = peers.remove(i);
conn.closeSocket();
fds.remove(i);
} else {
// We're in the child so any exception caught here has happened post
// fork and before we execute ActivityThread.main (or any other main()
// method). Log the details of the exception and bring down the process.
Log.e(TAG, "Caught post-fork exception in child process.", e);
throw e;
}
}
}
}
}
}
ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
这个函数首先创建两个链表，第一个链表 fds 是用来保存要监听的socket文件描述符。
第二个链表peers用来保存对应的socket文件上的事件处理函数
另外 fds 和 peers 中元素是有对应关键的，即：fds中的第i个元素所对应的处理类就是peers中的第i个元素。这个后面的代码中可以看出来
fds.add(mServerSocket.getFileDescriptor());
peers.add(null);
这里将mServerSocket.getFileDescriptor()添加到fds里面，就是将zygote自己创建的用来监听ActivityManager连接的socket添加到fds链表里面。因为这个socket上没有对应的事件处理类，因此其对应的peers中的处理类对象设置为null
StructPollfd[] pollFds = new StructPollfd[fds.size()];
for (int i = 0; i < pollFds.length; ++i) {// 填充pollFds
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);
}上面这个部分代码就是每次循环都会 根据 fds 的大小重新建立pollFds，然后开始监听。
// 上面的函数一旦监听到动作就会返回，然后执行下面的代码
for (int i = pollFds.length - 1; i >= 0; --i) {
if ((pollFds[i].revents & POLLIN) == 0) {
continue;
}
// 上面根据监听的pollFds的长度，循环从后到前，依次判断是哪个句柄上存在数据，获取存在数据的句柄
if (i == 0) { // 如果i等于0，就说明是zygote的socket上监听到了连接请求。
// 对于新的链接请求，这里会调用 acceptCommandPeer 函数，这个函数会调用 mServerSocket.accept() 接受连接，并返回句柄
// 然后用此句柄为参数创建了 ZygoteConnection 对象，然后由 ZygoteConnection 对象负责这一个连接的后续数据处理
ZygoteConnection newPeer = acceptCommandPeer(abiList);
peers.add(newPeer); // 将新创建的ZygoteConnection添加到 peers 这个列表中
fds.add(newPeer.getFileDesciptor()); // 添加到 fds，然后在下次循环的时候，将刚刚接受的链接请求也一同添加到监听。
} else { // 如果i不是0.就说明是已将连接的socket上有数据发送过来了
ZygoteConnection connection = peers.get(i); // 从刚刚记录的peers中获取处理对应数据的 ZygoteConnection 类
final Runnable command = connection.processOneCommand(this); // 调用processOneCommand 函数处理socket发送过来的数据。
if (mIsForkChild) { // 由于前面processOneCommand函数很可能会创建新的进程，因此当再次返回这里的时候，有可能会有两个进程这里就需要判断是在那个进程中
// 这里是在子进程。表示在processOneCommand中fork了新的进程，此时返回来的时候，新的进程会设置 mIsForkChild 标志位
if (command == null) {
throw new IllegalStateException("command == null");
}
return command;
} else {
// 这里是在父进程中。表示的时候 zygote 进程，
// 下面会关闭socket，并且将此socket的文件句柄，以及对应的处理类从链表中移除。
if (connection.isClosedByPeer()) {
connection.closeSocket();
peers.remove(i);
fds.remove(i);
}
}
}
}下面我们看下acceptCommandPeer函数的具体实现：
/**
* Waits for and accepts a single command connection. Throws
* RuntimeException on failure.
// socket编程中，accept()调用主要用在基于连接的套接字类型，比如SOCK_STREAM和SOCK_SEQPACKET
// 它提取出所监听套接字的等待连接队列中第一个连接请求，创建一个新的套接字，并返回指向该套接字的文件描述符
// 新建立的套接字不在监听状态，原来所监听的套接字的状态也不受accept()调用的影响
// 从代码，可以看出 acceptCommandPeer 调用了server socket的accpet函数。于是当新的连接建立时，
// zygote将会创建出一个新的socket与其通信，并将该socket加入到fds中。因此，一旦通信连接建立后，fds中将会包含有多个socket（我这里表述有点问题，这里实际上是同一个socket上面的不同的链接，请读者注意下）
*/
private ZygoteConnection acceptCommandPeer(String abiList) {
try {
// 注意这里的参数中调用了 mServerSocket.accept()
return createNewConnection(mServerSocket.accept(), abiList);
} catch (IOException ex) {
throw new RuntimeException(
"IOException during accept()", ex);
}
}
protected ZygoteConnection createNewConnection(LocalSocket socket, String abiList)
throws IOException {
// 这里根据参数，直接创建ZygoteConnection类对象
return new ZygoteConnection(socket, abiList);
}
下面是ZygoteConnection的构造函数
/**
* Constructs instance from connected socket.
*
* @param socket non-null; connected socket
* @param abiList non-null; a list of ABIs this zygote supports.
* @throws IOException
*/
ZygoteConnection(LocalSocket socket, String abiList) throws IOException {
mSocket = socket;
this.abiList = abiList;
mSocketOutStream= new DataOutputStream(socket.getOutputStream());
mSocketReader = new BufferedReader(new InputStreamReader(socket.getInputStream()), 256);
mSocket.setSoTimeout(CONNECTION_TIMEOUT_MILLIS);
try {
peer = mSocket.getPeerCredentials();
} catch (IOException ex) {
Log.e(TAG, "Cannot read peer credentials", ex);
throw ex;
}
isEof = false;
}上面的代码流程很清晰，就是创建了一个ZygoteConnection对象。这个对象是用来处理这个socket具体发送过来的数据的。
下面我们在看下processOneCommand函数的具体实现。看看ZygoteConnection类中的processOneCommand函数都干了什么。
/**
* Reads one start command from the command socket. If successful, a child is forked and a
* {@code Runnable} that calls the childs main method (or equivalent) is returned in the child
* process. {@code null} is always returned in the parent process (the zygote).
*
* If the client closes the socket, an {@code EOF} condition is set, which callers can test
* for by calling {@code ZygoteConnection.isClosedByPeer}.
*/
Runnable processOneCommand(ZygoteServer zygoteServer) {
String args[];
Arguments parsedArgs = null;
FileDescriptor[] descriptors;
try {
args = readArgumentList(); // 从socket 中读取传递过来的各种参数
descriptors = mSocket.getAncillaryFileDescriptors();
} catch (IOException ex) {
throw new IllegalStateException("IOException on command socket", ex);
}
// readArgumentList returns null only when it has reached EOF with no available
// data to read. This will only happen when the remote socket has disconnected.
if (args == null) {
isEof = true;
return null;
}
int pid = -1;
FileDescriptor childPipeFd = null;
FileDescriptor serverPipeFd = null;
// parsedArgs 这个类是个工具类，主要是保存 并解析上面传递的参数，并保存解析的结果
// 这里根据读取到的数据，来构建Arguments类，这个类会解析传递过来的数据，并保存解析的结果
parsedArgs = new Arguments(args);
if (parsedArgs.abiListQuery) { // 查询 AbiList
handleAbiListQuery();
return null;
}
if (parsedArgs.preloadDefault) { // 加载，并返回结果
handlePreload();
return null;
}
if (parsedArgs.preloadPackage != null) { // 预加载，
handlePreloadPackage(parsedArgs.preloadPackage, parsedArgs.preloadPackageLibs,
parsedArgs.preloadPackageCacheKey);
return null;
}
if (parsedArgs.permittedCapabilities != 0 || parsedArgs.effectiveCapabilities != 0) {
throw new ZygoteSecurityException("Client may not specify capabilities: " +
"permitted=0x" + Long.toHexString(parsedArgs.permittedCapabilities) +
", effective=0x" + Long.toHexString(parsedArgs.effectiveCapabilities));
}
// 安全检查
applyUidSecurityPolicy(parsedArgs, peer);
applyInvokeWithSecurityPolicy(parsedArgs, peer);
applyDebuggerSystemProperty(parsedArgs);
applyInvokeWithSystemProperty(parsedArgs);
int[] fdsToIgnore = null;
Log.e(TAG, " processOneCommand parsedArgs.invokeWith = "+parsedArgs.invokeWith);
if (parsedArgs.invokeWith != null) { // 这里好像一直都是空的，因此这里进不去
try {
FileDescriptor[] pipeFds = Os.pipe2(O_CLOEXEC); // 获取管道通讯的两端
childPipeFd = pipeFds[1]; // 写入端
serverPipeFd = pipeFds[0]; // 读取端
Os.fcntlInt(childPipeFd, F_SETFD, 0);
fdsToIgnore = new int[]{childPipeFd.getInt$(), serverPipeFd.getInt$()};
} catch (ErrnoException errnoEx) {
throw new IllegalStateException("Unable to set up pipe for invoke-with", errnoEx);
}
}
/**
* In order to avoid leaking descriptors to the Zygote child,
* the native code must close the two Zygote socket descriptors
* in the child process before it switches from Zygote-root to
* the UID and privileges of the application being launched.
*
* In order to avoid "bad file descriptor" errors when the
* two LocalSocket objects are closed, the Posix file
* descriptors are released via a dup2() call which closes
* the socket and substitutes an open descriptor to /dev/null.
*/
int [] fdsToClose = { -1, -1 };
FileDescriptor fd = mSocket.getFileDescriptor();
if (fd != null) {
fdsToClose[0] = fd.getInt$();
}
fd = zygoteServer.getServerSocketFileDescriptor();
if (fd != null) {
fdsToClose[1] = fd.getInt$();
}
fd = null;
// 创建子进程
pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,
parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,
parsedArgs.niceName, fdsToClose, fdsToIgnore, parsedArgs.instructionSet,
parsedArgs.appDataDir);
try {
if (pid == 0) {
// in child
// 因为子进程是复制于父进程，因此在子进程中 他的 mIsForkChild 值依然是父进程的原始值，false
// 此时调用 setForkChild 只会设置子进程中的 mIsForkChild 变量的值，
zygoteServer.setForkChild(); //设置标志.这样在这个地方返回的时候，zygoteServer 就会走到子进程的处理函数中了
zygoteServer.closeServerSocket(); // 关闭子线程中的 socket，这个socket是从zygote集成过来的，因此这里需要首选关闭掉。
IoUtils.closeQuietly(serverPipeFd); // 关闭流
serverPipeFd = null;
return handleChildProc(parsedArgs, descriptors, childPipeFd);
} else {
// In the parent. A pid < 0 indicates a failure and will be handled in
// handleParentProc. 这里是在父进程中
IoUtils.closeQuietly(childPipeFd);
childPipeFd = null;
handleParentProc(pid, descriptors, serverPipeFd);
return null;
}
} finally {
IoUtils.closeQuietly(childPipeFd);
IoUtils.closeQuietly(serverPipeFd);
}
}这个函数的流程比较简单，首先读取对端发送过来的数据，然后根据发送过来的数据构建Arguments这个类，这类会解析传递过来的参数，并保存解析的结果。然后根据解析情况进行各种判断。然后调用Zygote.forkAndSpecialize创建新的进程，这个函数会有两次返回，第一次是在原来的父进程中返回，第二次是在新创建的子进程中返回。从这个函数返回起，子进程和父进程就分道扬镳了，这个时候，我们需要注意下自己看的这部分代码是在子线程中还是在父进程中。
下面我们在贴下forkAndSpecialize函数的代码
public static int forkAndSpecialize(int uid, int gid, int[] gids, int debugFlags,
int[][] rlimits, int mountExternal, String seInfo, String niceName, int[] fdsToClose,
int[] fdsToIgnore, String instructionSet, String appDataDir) {
VM_HOOKS.preFork(); // 这里会等待zygote的所有子线程都退出即：停止Zyote的4个Daemon子线程的运行，初始化gc堆
// Resets nice priority for zygote process.
resetNicePriority(); // 设置zygote进程的优先级为 normal
int pid = nativeForkAndSpecialize(
uid, gid, gids, debugFlags, rlimits, mountExternal, seInfo, niceName, fdsToClose,
fdsToIgnore, instructionSet, appDataDir);
// Enable tracing as soon as possible for the child process.
if (pid == 0) {
// 子进程中
Trace.setTracingEnabled(true, debugFlags);
// Note that this event ends at the end of handleChildProc,
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "PostFork");
}
VM_HOOKS.postForkCommon(); // 启动4个Deamon子线程
return pid;
}
下面我们看下handleChildProc函数的大体流程
private Runnable handleChildProc(Arguments parsedArgs, FileDescriptor[] descriptors,
FileDescriptor pipeFd) {
closeSocket(); // 关闭socket。这个socket 根前面刚刚关闭的socket不是同一个
if (parsedArgs.niceName != null) { // 设置子进程的名称
Process.setArgV0(parsedArgs.niceName);
}
// End of the postFork event.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
if (parsedArgs.invokeWith != null) { // 这里好像一直都是空的
WrapperInit.execApplication(parsedArgs.invokeWith,
parsedArgs.niceName, parsedArgs.targetSdkVersion,
VMRuntime.getCurrentInstructionSet(),
pipeFd, parsedArgs.remainingArgs);
// Should not get here.
throw new IllegalStateException("WrapperInit.execApplication unexpectedly returned");
} else { // 这里调用 ZygoteInit.zygoteInit 进一步初始化
return ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs,
null /* classLoader */);
}
}下面我们看下ZygoteInit.zygoteInit的实现
// 这个函数是一个公共的函数，启动 systemServer 以及启动 应用都会调用到这里
public static final Runnable zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) {
if (RuntimeInit.DEBUG) {
Slog.d(RuntimeInit.TAG, "RuntimeInit: Starting application from zygote");
}
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ZygoteInit");
RuntimeInit.redirectLogStreams(); // 将system.out 以及System.err 的输出重定向到 Android log中
RuntimeInit.commonInit();
ZygoteInit.nativeZygoteInit(); // 初始化native层
return RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
}
下面是applicationInit函数的实现
protected static Runnable applicationInit(int targetSdkVersion, String[] argv,
ClassLoader classLoader) {
// 如果应用调用System.exit()直接终结一个进程，但是没有调用 shutdown hooks，这个对于一个Android应用了来说确实可以
// 但是shutdown hooks是用来关闭Binder的，如果没有调用，会导致一些线程遗留，造成crash
nativeSetExitWithoutCleanup(true);
// We want to be fairly aggressive about heap utilization, to avoid
// holding on to a lot of memory that isn't needed.
VMRuntime.getRuntime().setTargetHeapUtilization(0.75f); // 与内存占用相关
VMRuntime.getRuntime().setTargetSdkVersion(targetSdkVersion); // 设置sdk版本
final Arguments args = new Arguments(argv);
// The end of of the RuntimeInit event (see #zygoteInit).
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
// Remaining arguments are passed to the start class's static main
return findStaticMain(args.startClass, args.startArgs, classLoader);
}这个findStaticMain函数会根据传递的参数，找到对应的java类的静态main函数，然后 通过return new MethodAndArgsCaller(m, argv);来返回一个MethodAndArgsCaller类，下面我们看下MethodAndArgsCaller类的实现。
static class MethodAndArgsCaller implements Runnable {
/** method to call */
private final Method mMethod;
/** argument array */
private final String[] mArgs;
public MethodAndArgsCaller(Method method, String[] args) {
mMethod = method;
mArgs = args;
}
public void run() {
try {
mMethod.invoke(null, new Object[] { mArgs }); //这个会调用相应的方法并将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);
}
}
}这个类的实现很简单，就是保存要启动的函数对象，已经要传递的参数，然后提供一个 run函数来执行对应的函数并传递参数给这个函数。如果这里调用的是 SystemServer，那么这里就会调用SystemServer.java的main函数，如果是启动的应用，那就会调用ActivityThread.java 的main函数。
但是上面的findStaticMain并没有调用这个run函数，而是仅仅创建了一个类对象，然后就将这个对象返回了。那么这个函数是在哪里调用的呢，这里就一层一层的返回了，首先这里会返回到ZygoteConnection.java的processOneCommand 函数，然后这个函数接着返回，会返回到ZygoteServer.java中的runSelectLoop函数中，在这个函数有下面的代码：
if (mIsForkChild) {
// We're in the child. We should always have a command to run at this
// stage if processOneCommand hasn't called "exec".
// 这里是在子进程
if (command == null) {
throw new IllegalStateException("command == null");
}
return command; // 这里再次返回
}
上面的代码会继续返回到ZygoteInit.java中的main函数中；下面这部分代码就会main函数的处理函数。
// The select loop returns early in the child process after a fork and
// loops forever in the zygote.
caller = zygoteServer.runSelectLoop(abiList); // zygote进程进入无限循环，处理请求
} catch (Throwable ex) {
Log.e(TAG, "System zygote died with exception", ex);
throw ex;
} finally {
Log.i(TAG, "zygoteServer.closeServerSocket finally finally");
// 这个地方有两个调用的流程
// 1: zygote 进程退出的时候会调用这个函数，用来关闭zygote自己创建的用来接收ActivityManager的链接请求的socket
// 2：当每个子线程fork完毕，准备好之后，会走到这里，这个时候会在子进程中执行的，这里会调用closeServerSocket函数，确保从zygote集成过来的socket关闭。
// 其实这个时候，因为子进程刚刚fock出来的时候就已经掉用过closeServerSocket函数了，因此再次调用，是没有效果的
zygoteServer.closeServerSocket();
}
// We're in the child process and have exited the select loop. Proceed to execute the
// command.
if (caller != null) {
caller.run(); // 这里才是重点，上面会返回一个Runnable的对象，这个地方调用他的 run函数会进入到子进程的真正的main函数里面
}上面的这段代码，当zygoteServer.runSelectLoop返回的时候，就已经是在子进程中了，此时会在后面调用caller.run();来执行对应的java文件的main函数。至此zygote中启动新进程的流程就梳理完成了。
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
