從Zygote說到View（一）Zygote的啟動流程及執行機制
阿新 • • 發佈：2018-12-04
前言
計劃寫一個系列文章，從 Zygote 開始，說到 Activity，再到 View 的顯示及事件分發等，意在把 Android 開發中最核心的一些的知識點串成線，看看 Android 是怎麼把它們組織到一起的，希望能寫好。
本文是第一篇，以“Zygote 的啟動流程及執行機制”為題， 將打通“虛擬機器-Zygote-應用程序-ActivityThread”這一條線。
Zygote 的中文意思是受精卵、合子，可以理解為孵化器——Android 中大多數應用程序和系統程序都是通過 Zygote 來生成的。
PS：原始碼基於 Android API 27。
Zygote 是怎麼啟動的？
init
Android 的第一個程序為 init，init 通過解析 init.rc 來陸續啟動其它關鍵的系統服務程序——其中最重要的是 ServiceManager、Zygote 和 SystemServer。下面以 init.zygote64.rc 為例開始分析：
## 服務名、路徑、引數
service zygote /system/bin/app_process64 -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 audioserver
onrestart restart cameraserver
onrestart restart media
onrestart restart netd
writepid /dev/cpuset/foreground/tasks
複製程式碼 通過指定 --zygote 引數，app_process 可以識別出是否需要啟動 zygote。
虛擬機器的啟動
下面開始分析路徑 app_process 中的檔案 app_main.cpp ：
// app_process/app_main.cpp
int main(int argc, char* const argv[])
{
// 建立 Android 虛擬機器物件
AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
...
// Parse runtime arguments. Stop at first unrecognized option.
bool zygote = false 根據以上程式碼，可以知道 Zygote 運行於 Android 虛擬機器上，因為 AppRuntime 繼承於 AndroidRuntime：
class AppRuntime : public AndroidRuntime
{
public:
AppRuntime(char* argBlockStart, const size_t argBlockLength)
: AndroidRuntime(argBlockStart, argBlockLength)
, mClass(NULL)
{
}
...
}
複製程式碼AppRuntime 更多是處理一些事件完成後的回撥，主要的實現依然在 AndroidRuntime 中。因此下面直接看 AndroidRumtime::start 的實現：
/*
* Start the Android runtime. This involves starting the virtual machine
* and calling the "static void main(String[] args)" method in the class
* named by "className".
*
* Passes the main function two arguments, the class name and the specified
* options string.
*
* 該方法用於啟動 Android 虛擬機器，並呼叫 className 對應的類的 main 方法
*/
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
...
/* 啟動虛擬機器 */
JniInvocation jni_invocation;
jni_invocation.Init(NULL); // 初始化虛擬機器環境
JNIEnv* env;
if (startVm(&mJavaVM, &env, zygote) != 0) { // 啟動
return;
}
onVmCreated(env); // 回撥，通知虛擬機器已成功啟動
/*
* 註冊 Android 的 native 函式
*/
if (startReg(env) < 0) {
ALOGE("Unable to register all android natives\n");
return;
}
/*
* We want to call main() with a String array with arguments in it.
* At present we have two arguments, the class name and an option string.
* Create an array to hold them.
*
* 呼叫 className 對應的類的 main 方法，並傳入相應的引數
*/
jclass stringClass;
jobjectArray strArray;
jstring classNameStr;
stringClass = env->FindClass("java/lang/String");
strArray = env->NewObjectArray(options.size() + 1, stringClass, NULL);
classNameStr = env->NewStringUTF(className);
env->SetObjectArrayElement(strArray, 0, classNameStr);
// 設定引數
for (size_t i = 0; i < options.size(); ++i) {
jstring optionsStr = env->NewStringUTF(options.itemAt(i).string());
env->SetObjectArrayElement(strArray, i + 1, optionsStr);
}
/*
* Start VM. This thread becomes the main thread of the VM, and will
* not return until the VM exits.
*
* 當前執行緒會成為虛擬機器的主執行緒，除非虛擬機器退出，否則 main 方法會一直阻塞
*/
char* slashClassName = toSlashClassName(className != NULL ? className : "");
jclass startClass = env->FindClass(slashClassName); // 查詢 className 對應的類
if (startClass == NULL) {
...
} else {
jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
"([Ljava/lang/String;)V"); // 查詢 startClass 對應的 main 方法
if (startMeth == NULL) { // 未找到 main 方法
...
} else {
env->CallStaticVoidMethod(startClass, startMeth, strArray); // 呼叫 main 方法
}
}
// 結束虛擬機器執行
ALOGD("Shutting down VM\n");
if (mJavaVM->DetachCurrentThread() != JNI_OK)
ALOGW("Warning: unable to detach main thread\n");
if (mJavaVM->DestroyJavaVM() != 0)
ALOGW("Warning: VM did not shut down cleanly\n");
}
複製程式碼上面的程式碼還是很好懂的，主要作用是：
- 初始化虛擬機器環境
- 啟動虛擬機器
- 註冊 Android 的 native 介面，主要包括 Binder、OpenGL、Bitmap、Camera、AudioRecord 等
- 找到 ZygoteInit，傳遞引數，呼叫它的 main 方法，main 方法會一直阻塞直到虛擬機器退出
- 虛擬機器退出時銷燬相關資源
虛擬機器的相關流程忽略，假設 VM 成功啟動，那麼 com.android.internal.os.ZygoteInit（這個包名是 app_main.cpp 檔案傳過來的） 的 main 方法將會被呼叫，此時可以認為 Zygote 也隨之啟動了，即 Zygote 是由 Android 的第一個程序 init 解析檔案 init.rc 時啟動的。其中首先啟動的是 Android 虛擬機器，接著才是 Zygote，ZygoteInit 的 main 函式會一直阻塞執行，直到虛擬機器退出。
Zygote 是如何孵化子程序的？
下面開始分析 ZygoteInit 的 main 方法：
/**
* Startup class for the zygote process.
*/
public class ZygoteInit {
public static void main(String argv[]) {
ZygoteServer zygoteServer = new ZygoteServer(); // 建立 Zygote 的 Server Socket 物件
...
final Runnable caller;
try {
...
boolean startSystemServer = false;
String socketName = "zygote";
String abiList = null;
boolean enableLazyPreload = false;
for (int i = 1; i < argv.length; i++) {
if ("start-system-server".equals(argv[i])) { // init.rc 指定了引數--start-system-server
startSystemServer = true;
} else if ("--enable-lazy-preload".equals(argv[i])) {
...
} else {
...
}
}
// 註冊 Socket
zygoteServer.registerServerSocket(socketName);
if (!enableLazyPreload) {
// 預載入所有應用需要的公共資源
preload(bootTimingsTraceLog);
} else {
Zygote.resetNicePriority();
}
...
if (startSystemServer) {
// fork 一個 SystemServer 程序
Runnable r = forkSystemServer(abiList, socketName, zygoteServer);
// {@code r == null} in the parent (zygote) process, and {@code r != null} in the
// child (system_server) process.
if (r != null) {
r.run();
return;
}
}
// The select loop returns early in the child process after a fork and
// loops forever in the zygote.
// Zygote 程序會在一個死迴圈上等待連線
caller = zygoteServer.runSelectLoop(abiList);
} catch (Throwable ex) {
Log.e(TAG, "System zygote died with exception", ex);
throw ex;
} finally {
zygoteServer.closeServerSocket(); // Zygote 退出了死迴圈，關閉 Socket
}
// We're in the child process and have exited the select loop. Proceed to execute the command.
// 當前是子程序，且退出了迴圈，則繼續執行命令
if (caller != null) {
caller.run();
}
}
}
複製程式碼從程式碼中可以看出，ZygoteInit 主要完成 4 項工作：
- 註冊一個 Socket。Zygote 是一個孵化器，一旦有新程式需要執行時，系統會通過這個 Socket 在第一時間通知它孵化一個程序
- 預載入各類資源
- 啟動 SystemServer。Zygote 只會初始化一次，因此它需要新建一個專門的程序來承載系統服務的執行
- 進入死迴圈，不斷地處理 Socket 請求
由此可以知道，Zygote 主要是通過 Socket 來處理客戶端的請求的。下面將對以上幾項工作逐個進行分析。
註冊 Socket
class ZygoteServer {
private static final String ANDROID_SOCKET_PREFIX = "ANDROID_SOCKET_";
private LocalServerSocket mServerSocket;
void registerServerSocket(String socketName) {
if (mServerSocket == null) {
int fileDesc;
final String fullSocketName = ANDROID_SOCKET_PREFIX + socketName; // socketName 為 "zygote"
try {
String env = System.getenv(fullSocketName);
fileDesc = Integer.parseInt(env);
} catch (RuntimeException ex) {
throw new RuntimeException(fullSocketName + " unset or invalid", ex);
}
try {
FileDescriptor fd = new FileDescriptor();
fd.setInt$(fileDesc);
mServerSocket = new LocalServerSocket(fd); // 建立 Server Socket
} catch (IOException ex) {
throw new RuntimeException(
"Error binding to local socket '" + fileDesc + "'", ex);
}
}
}
}
複製程式碼LocalServerSocket 的構造方法如下：
/**
* Non-standard class for creating an inbound UNIX-domain socket
* in the Linux abstract namespace.
*/
public class LocalServerSocket {
private final LocalSocketImpl impl;
private final LocalSocketAddress localAddress;
public LocalServerSocket(String name) throws IOException {
impl = new LocalSocketImpl(); // Socket 實現類
impl.create(LocalSocket.SOCKET_STREAM); // TCP 連線
localAddress = new LocalSocketAddress(name);
impl.bind(localAddress); // 繫結
impl.listen(LISTEN_BACKLOG); // 監聽
}
}
複製程式碼可以看到，registerServerSocket 的作用是建立一個名為 "ANDROID_SOCKET_zygote" 的 Socket 物件，並繫結對應的埠，開始監聽來自其他程序的請求。根據註釋可以看出，這個 Socket 是一個 UNIX-domain Socket，這種 Socket 適用於單個裝置內的程序間通訊，這是除 Binder 外，Android 執行程序間通訊時最常用的一種方式。
preload
下面簡單看一下 preload 方法：
public class ZygoteInit {
static void preload(TimingsTraceLog bootTimingsTraceLog) {
Log.d(TAG, "begin preload");
beginIcuCachePinning();
preloadClasses();
preloadResources();
nativePreloadAppProcessHALs();
preloadOpenGL();
preloadSharedLibraries();
preloadTextResources();
// Ask the WebViewFactory to do any initialization that must run in the zygote process,
// for memory sharing purposes.
WebViewFactory.prepareWebViewInZygote();
endIcuCachePinning();
warmUpJcaProviders();
Log.d(TAG, "end preload");
sPreloadComplete = true;
}
}
複製程式碼可以看到，preload 主要的工作是預載入各種類、HAL 層資源、OpenGL 環境、共享庫、文字資源、WebView 資源等。
forkSystemServer
現在看 forkSystemServer，它用於啟動 SystemServer 程序，SystemServer 是 Android framework 中特別關鍵的一個類，用於啟動各種系統服務：
public class ZygoteInit {
/**
* Prepare the arguments and forks for the system server process.
*
* Returns an {@code Runnable} that provides an entrypoint into system_server code in the
* child process, and {@code null} in the parent.
*/
private static Runnable forkSystemServer(String abiList, String socketName,
ZygoteServer zygoteServer) {
...
/* 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,1023,1032,3001,3002,3003,3006,3007,3009,3010",
"--capabilities=" + capabilities + "," + capabilities,
"--nice-name=system_server",
"--runtime-args",
"com.android.server.SystemServer", // 注意這個引數
};
ZygoteConnection.Arguments parsedArgs = null;
int pid;
try {
// 編譯引數到 ZygoteConnection 中
parsedArgs = new ZygoteConnection.Arguments(args);
ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);
/* Request to fork the system server process */
// 請求 fork 一個 SystemServer 程序
pid = Zygote.forkSystemServer(
parsedArgs.uid, parsedArgs.gid,
parsedArgs.gids,
parsedArgs.debugFlags,
null,
parsedArgs.permittedCapabilities,
parsedArgs.effectiveCapabilities);
} catch (IllegalArgumentException ex) {
throw new RuntimeException(ex);
}
/* For child process */
// 子程序，即 SystemServer 的程序
if (pid == 0) {
if (hasSecondZygote(abiList)) {
waitForSecondaryZygote(socketName);
}
zygoteServer.closeServerSocket();
return handleSystemServerProcess(parsedArgs); // 啟動 SystemServer
}
return null;
}
}
複製程式碼可以看到，forkSystemServer 先是通過 Zygote fork 了一個程序，接著呼叫 handleSystemServerProcess 來啟動 SystemServer。Zygote 的實現如下：
public final class Zygote {
/**
* Special method to start the system server process.
*/
public static int forkSystemServer(int uid, int gid, int[] gids, int debugFlags,
int[][] rlimits, long permittedCapabilities, long effectiveCapabilities) {
...
int pid = nativeForkSystemServer(
uid, gid, gids, debugFlags, rlimits, permittedCapabilities, effectiveCapabilities);
...
return pid;
}
}
複製程式碼fork 程序的操作是通過原生代碼實現的：
// com_android_internal_os_Zygote.cpp
static const char kZygoteClassName[] = "com/android/internal/os/Zygote";
static jclass gZygoteClass;
static jmethodID gCallPostForkChildHooks;
static jint com_android_internal_os_Zygote_nativeForkAndSpecialize(...) {
...
return ForkAndSpecializeCommon(env, uid, gid, gids, debug_flags,
rlimits, capabilities, capabilities, mount_external, se_info,
se_name, false, fdsToClose, fdsToIgnore, instructionSet, appDataDir);
}
// Utility routine to fork zygote and specialize the child process.
static pid_t ForkAndSpecializeCommon(...) {
...
pid_t pid = fork(); // 這裡才真正 fork 了一個新的程序
if (pid == 0) {
...
// 回撥 Zygote 的 callPostForkChildHooks，通知虛擬機器子程序已建立完畢
env->CallStaticVoidMethod(gZygoteClass, gCallPostForkChildHooks, debug_flags,
is_system_server, instructionSet);
} else if (pid > 0) {
// 父程序，什麼都不做
}
return pid;
}
複製程式碼可以看到，原生代碼呼叫的是 Linux 的 fork 函式，此時一個新的程序就已經建立完畢了，下面看 handleSystemServerProcess：
public class ZygoteInit {
/**
* Finish remaining work for the newly forked system server process.
* 注意引數 parsedArgs 是 forkSystemServer 傳過來的，包含了 SystemServer 的包名
*/
private static Runnable handleSystemServerProcess(ZygoteConnection.Arguments parsedArgs) {
...
if (parsedArgs.invokeWith != null) { // 比較 forkSystemServer 中的引數，可知這裡為 null
...
} else {
ClassLoader cl = null;
if (systemServerClasspath != null) { // 找到 SystemServer 對應的 ClassLoader
cl = createPathClassLoader(systemServerClasspath, parsedArgs.targetSdkVersion);
Thread.currentThread().setContextClassLoader(cl);
}
/*
* Pass the remaining arguments to SystemServer.
*/
return ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
}
}
public static final Runnable zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) {
...
ZygoteInit.nativeZygoteInit();
return RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
}
private static final native void nativeZygoteInit();
}
複製程式碼handleSystemServerProcess 主要做了 3 件事：
- 找到 SystemServer 對應的 ClassLoader
- 呼叫 nativeZygoteInit
- 呼叫 RuntimeInit.applicationInit
下面看 nativeZygoteInit：
// framework/base/core/jni/AndroidRuntime.cpp
static void com_android_internal_os_ZygoteInit_nativeZygoteInit(JNIEnv* env, jobject clazz)
{
gCurRuntime->onZygoteInit();
}
複製程式碼onZygoteInit 等方法回撥是 AndroidRuntime 子類 AppRuntime 實現的：
class AppRuntime : public AndroidRuntime
{
public:
...
virtual void onZygoteInit()
{
sp<ProcessState> proc = ProcessState::self();
proc->startThreadPool();
}
}
複製程式碼startThreadPool 將開啟 Binder 執行緒池以保證其它程序可以正確訪問到 Zygote 所提供的服務，startThreadPool 的原始碼實現跳過，繼續看 RuntimeInit.applicationInit：
public class RuntimeInit {
protected static Runnable applicationInit(int targetSdkVersion, String[] argv,
ClassLoader classLoader) {
...
// Remaining arguments are passed to the start class's static main
return findStaticMain(args.startClass, args.startArgs, classLoader);
}
private static Runnable findStaticMain(String className, String[] argv,
ClassLoader classLoader) {
Class<?> cl;
try {
cl = Class.forName(className, true, classLoader); // 載入 SystemServer 類
} catch (ClassNotFoundException ex) {
...
}
Method m;
try {
m = cl.getMethod("main", new Class[] { String[].class }); // 找到 SystemServer 類的 main 方法
} catch (NoSuchMethodException ex) {
...
}
return new MethodAndArgsCaller(m, argv);
}
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 }); // 呼叫 SystemServer 的 main 方法
} catch (IllegalAccessException ex) {
...
}
}
}
}
複製程式碼可以看到，applicationInit 的作用就是返回一個能夠呼叫 SystemServer 的 main 方法的 Runnable，這個 Runnable 將會在 ZygoteInit 的 main 方法中被呼叫。也就是說，applicationInit 返回的 Runnable 物件會被馬上執行，此時 SystemServer 的 main 方法會被呼叫，並啟動眾多系統服務。
這裡對 forkSystemServer 的作用做一個小結：
- fork 一個新的程序
- 找到 SystemServer 對應的類載入器
- 呼叫 SystemServer 的 main 方法，啟動 SystemServer
runSelectLoop
forkSystemServer 分析完畢，接下來看 runSelectLoop：
class ZygoteServer {
private LocalServerSocket mServerSocket;
/**
* 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) {
...
while (true) {
...
for (int i = pollFds.length - 1; i >= 0; --i) {
if ((pollFds[i].revents & POLLIN) == 0) {
continue;
}
if (i == 0) {
...
} else {
try {
ZygoteConnection connection = peers.get(i);
final Runnable command = connection.processOneCommand(this);
if (mIsForkChild) { // 如果當前是子程序
// We're in the child. We should always have a command to run at this
// stage if processOneCommand hasn't called "exec".
// 在執行 exec 命令之前，子程序的 command 不應該為 null
if (command == null) {
throw new IllegalStateException("command == null");
}
return command;
} else { // 父程序
// We're in the server - we should never have any commands to run.
// 在 server 程序中，不應該有任何需要執行的命令
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) {
...
}
}
}
}
}
}
複製程式碼可以看到，runSelectLoop 就是一個死迴圈，它會不斷地獲取 ZygoteConnection，並執行對應的命令，直到出現異常，或連線關閉。下面看它是如何執行命令的：
class ZygoteConnection {
Runnable processOneCommand(ZygoteServer zygoteServer) {
...
// fork 一個程序，這個方法和前面介紹過的 forkSystemServer 基本是一致的
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 標記為子程序
zygoteServer.setForkChild();
zygoteServer.closeServerSocket();
serverPipeFd = null;
// 新建立的程序需要執行應用程式本身的程式碼
return handleChildProc(parsedArgs, descriptors, childPipeFd);
} else {
...
// 父程序的掃尾工作，包括：將子程序加入程序組、正確關閉檔案、呼叫方返回結果值等
handleParentProc(pid, descriptors, serverPipeFd);
return null;
}
} finally {
...
}
}
}
複製程式碼簡單看一下 handleChildProc：
class ZygoteConnection {
/**
* Handles post-fork setup of child proc, closing sockets as appropriate,
* reopen stdio as appropriate, and ultimately throwing MethodAndArgsCaller
* if successful or returning if failed.
*/
private Runnable handleChildProc(Arguments parsedArgs, FileDescriptor[] descriptors,
FileDescriptor pipeFd) {
closeSocket();
...
if (parsedArgs.niceName != null) {
Process.setArgV0(parsedArgs.niceName);
}
if (parsedArgs.invokeWith != null) {
... // 拼接 init.rc 命令，啟動對應的服務
} else {
// 前面分析過
return ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs,
null /* classLoader */);
}
}
}
複製程式碼可以看到，和 handleSystemServerProc 類似，handleChildProc 最終會呼叫 ZygoteInit.zygoteInit，以開啟一個 Binder 執行緒池，並執行對應的類的 main 方法。
小結一下，runSelectLoop 的作用為：不斷處理來自 Socket 的請求。對於每個請求，Zygote 會 fork 一個程序，並開啟 Binder 執行緒池，以便子程序能夠和系統程序進行互動，最後呼叫指定的類的 main 方法——實際上，一個新的 Application 啟動時，被呼叫的是 ActivityThread 的 main 方法。
如此，從 Android 虛擬機器的啟動，到 Zygote 的啟動，再到應用程序的啟動、ActivityThread 的執行，這一條線就基本連起來了。
總結
連線中的一些關鍵的點：
- Android 虛擬機器和 Zygote 是 init 程序通過解析 init.rc 檔案啟動的，init.rc 檔案指定了引數 Zygote 及 SystemServer
- Android 虛擬機器成功啟動後，會呼叫 ZygoteInit 的 main 方法，main 方法會阻塞執行直到虛擬機器退出
- ZygoteInit 的 main 方法首先會註冊一個 UNIX-domain Socket，用於監聽來自客戶端的請求
- 接著預載入各類資源，包括 HAL 層資源、OpenGL 環境以及各種類等
- 然後 fork 一個程序用於執行 SystemServer，並呼叫 SystemServer 的 main 方法，啟動各類服務
- 最後進入一個死迴圈，不斷地處理 Socket 請求
- 當有新的請求到來時，Zygote 會 fork 一個程序，並開啟 Binder 執行緒池，以便子程序能夠和系統程序進行互動，最後呼叫 ActivityThread 的 main 方法
流程圖：