本篇文章已授权微信公众号 顾林海 独家发布
Zygote进程启动过程
在Android系统中，所有的应用程序及系统服务SystemServer进程都由Zygote进程通过Linux的for()函数孵化出来的，因此我们称Zygote是孵化器。
在前面知道了init启动Zygote的相关操作在app_main.cpp的main函数中的，代码如下：
int main(int argc, char* const argv[])
{
...
while (i < argc) {
const char* arg = argv[i++];
if (strcmp(arg, "--zygote") == 0) {
//注释1
zygote = true;
niceName = ZYGOTE_NICE_NAME;
} else if (strcmp(arg, "--start-system-server") == 0) {
startSystemServer = true;
} else if (strcmp(arg, "--application") == 0) {
application = true;
} else if (strncmp(arg, "--nice-name=", 12) == 0) {
niceName.setTo(arg + 12);
} else if (strncmp(arg, "--", 2) != 0) {
className.setTo(arg);
break;
} else {
--i;
break;
}
}
...
if (zygote) {
//注释2
runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
} else if (className) {
runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
} else {
fprintf(stderr, "Error: no class name or --zygote supplied.\n");
app_usage();
LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
}
}
main函数中通过前面的if条件判断语句来区分当前运行在哪个进程，如果是Zygote进程，就会在注释1处将zygote赋值为true，同时执行注释2处的runtime的start函数。
Zygote进程孵化子进程是通过自己的资源复制一份，来fork一个新的子进程，也就是说子进程进入这个文件的main函数，因此，这里的main函数被调用并不只是Zygote启动的时候调用。既然子进程启动的时候同样被调用，那么怎么区分是被Zygote进程本身调用的还是它的子进程调用的呢？这里就通过zygote这个变量来区分，如果是Zygote进程本身，变量zygote为true，否则就会进入到下面的else if里，代表子进程启动。
runtime是一个AppRuntime对象，AppRuntime类继承AndroidRuntime类，因此前面调用的是AndroidRuntime的start函数，代码如下所示：
//路径：/frameworks/base/core/jni/AndroidRuntime.cpp
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
...
/* start the virtual machine */
JniInvocation jni_invocation;
jni_invocation.Init(NULL);
JNIEnv* env;
//启动Java虚拟机
if (startVm(&mJavaVM, &env, zygote) != 0) {
return;
}
onVmCreated(env);
//注册JNI方法
if (startReg(env) < 0) {
ALOGE("Unable to register all android natives\n");
return;
}
...
//注释1
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);
}
//将className中的“.”替换成“/”
//注释2
char* slashClassName = toSlashClassName(className);
//注释3
jclass startClass = env->FindClass(slashClassName);
if (startClass == NULL) {
...
} else {
//注释4
jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
"([Ljava/lang/String;)V");
if (startMeth == NULL) {
...
} else {
//注释5
env->CallStaticVoidMethod(startClass, startMeth, strArray);
#if 0
if (env->ExceptionCheck())
threadExitUncaughtException(env);
#endif
}
}
...
}
AndroidRuntime的start函数主要做了以下几件事：
- 通过startVm函数启动Java虚拟机。
- 通过startReg函数注册JNI方法。
- 调用com.android.internal.os.ZygoteInit类的main函数。
其中注释1处的传递过来的className值是com.android.internal.os.ZygoteInit，在注释2处将className中的“.”全部替换为“/”，替换后的值是com/android/internal/os/ZygoteInit，在注释3处获取ZygoteInit类，在注释4处获取ZygoteInit的main方法，最后在注释5处通过JNI调用ZygoteInit的main方法，至此我们进入Java框架层。
ZygoteInit类的main方法如下所示：
//路径：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
public static void main(String argv[]) {
ZygoteServer zygoteServer = new ZygoteServer();
...
try {
...
//注释1
zygoteServer.registerServerSocket(socketName);
if (!enableLazyPreload) {
...
//注释2
preload(bootTimingsTraceLog);
...
} else {
Zygote.resetNicePriority();
}
...
//注释3
if (startSystemServer) {
startSystemServer(abiList, socketName, zygoteServer);
}
//注释4
zygoteServer.runSelectLoop(abiList);
zygoteServer.closeServerSocket();
} catch (Zygote.MethodAndArgsCaller caller) {
caller.run();
} catch (Throwable ex) {
Log.e(TAG, "System zygote died with exception", ex);
zygoteServer.closeServerSocket();
throw ex;
}
}
ZygoteInit的main方法中，注释1处通过registerServerSocket方法创建一个Zygote的Socket接口用来和AMS通信。查看registerServerSocket方法：
//路径：/frameworks/base/core/java/com/android/internal/os/ZygoteServer.java
void registerServerSocket(String socketName) {
if (mServerSocket == null) {
...
try {
...
//注释1
mServerSocket = new LocalServerSocket(fd);
} catch (IOException ex) {
throw new RuntimeException(
"Error binding to local socket '" + fileDesc + "'", ex);
}
}
}
注释1处创建了一个Java层的LocalServerSocket对象ServerSocket，用于等待创建新的应用程序进程请求连接。
ZygoteInit的main方法中，注释2处通过preload方法预加载类和资源，如果系统不预加载类和资源，每次启动一个应用程序都会去加载这些类和资源，那么启动应用程序的时间就会很长。
ZygoteInit的main方法中，注释3处通过startSystemServer方法启动SystemServer进程。查看startSystemServer方法：
//路径：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
private static boolean startSystemServer(String abiList, String socketName, ZygoteServer zygoteServer)
throws Zygote.MethodAndArgsCaller, RuntimeException {
...
//注释1
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 {
parsedArgs = new ZygoteConnection.Arguments(args);
...
//注释2
pid = Zygote.forkSystemServer(
parsedArgs.uid, parsedArgs.gid,
parsedArgs.gids,
parsedArgs.debugFlags,
null,
parsedArgs.permittedCapabilities,
parsedArgs.effectiveCapabilities);
} catch (IllegalArgumentException ex) {
throw new RuntimeException(ex);
}
//注释3
if (pid == 0) {
if (hasSecondZygote(abiList)) {
waitForSecondaryZygote(socketName);
}
zygoteServer.closeServerSocket();
//注释4
handleSystemServerProcess(parsedArgs);
}
return true;
}
注释1处args数组保存的是SystemServer的启动参数，最后封装成Arguments对象，在注释2处通过Zygote的forkSystemServer方法创建子进程，该方法内部会调用nativeForkSystemServer这个Native方法，nativeForkSystemServer方法最终通过fork函数创建一个子进程。在注释3处，判断pid是否等于0，如果等于0，说明当前的代码运行在新创建的子进程中，最后通过注释4处的handleSystemServerProcess方法启动SystemServer进程。
ZygoteInit的main方法中，注释4处调用runSlectLoop方法，通过前面创建的Socket接口，进入一个无限循环，等待核心服务ActivityManagerService请求创建新的应用程序进程。查看runSlectLoop方法：
//路径：/frameworks/base/core/java/com/android/internal/os/ZygoteServer.java
void runSelectLoop(String abiList) throws Zygote.MethodAndArgsCaller {
...
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;
}
//注释1处
if (i == 0) {
ZygoteConnection newPeer = acceptCommandPeer(abiList);
peers.add(newPeer);
fds.add(newPeer.getFileDesciptor());
} else {
boolean done = peers.get(i).runOnce(this);
if (done) {
peers.remove(i);
fds.remove(i);
}
}
}
}
}
在注释1处，如果i==0，说明Zygote的Socket服务还没准备好，接下来通过acceptCommandPeer方法得到ZygoteConnection对象，并添加到Socket连接列表peers中，同时将这个ZygoteConnection的fd添加到fd列表fds中，以便可以接收到AMS发送过来的请求。如果i!=0，说明正在等待客户端来连接服务端的Socket，当AMS向Zygote进程发送一个创建应用程序进程的请求时，就会调用ZygoteConnection的runOnce()函数来创建应用程序进程的请求，成功创建后从Socket连接列表peers和fd列表中清除这个连接。
SystemServer进程
SystemServer进程主要用于创建系统服务，比如AMS、WMS和PMS都是由它来创建的，SystemServer进程与普通的应用程序进程运行在不同的进程里面，应用进程调用的API，很多都是通过Binder机制调用到SystemServer进程中对应的服务上的。
在ZygoteInit的main函数中通过startSystemServer函数来启动SystemServer进程。查看startSystemServer方法：
//路径：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
private static boolean startSystemServer(String abiList, String socketName, ZygoteServer zygoteServer)
throws Zygote.MethodAndArgsCaller, RuntimeException {
...
//注释1
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 {
parsedArgs = new ZygoteConnection.Arguments(args);
...
//注释2
pid = Zygote.forkSystemServer(
parsedArgs.uid, parsedArgs.gid,
parsedArgs.gids,
parsedArgs.debugFlags,
null,
parsedArgs.permittedCapabilities,
parsedArgs.effectiveCapabilities);
} catch (IllegalArgumentException ex) {
throw new RuntimeException(ex);
}
//注释3
if (pid == 0) {
if (hasSecondZygote(abiList)) {
waitForSecondaryZygote(socketName);
}
//注释5
zygoteServer.closeServerSocket();
//注释4
handleSystemServerProcess(parsedArgs);
}
return true;
}
这段代码在上面已经介绍过，最后通过handleSystemServerProcess方法启动SystemServer进程，由于SystemServer是Zygote进程fork出来的，SystemServer进程也有一份Socket，但这个Socket对SystemServer进程没有什么用处，因此通过注释5处关闭这个Socket。handleSystemServerProcess方法的代码如下所示：
//路径：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
private static void handleSystemServerProcess(
ZygoteConnection.Arguments parsedArgs)
throws Zygote.MethodAndArgsCaller {
...
if (systemServerClasspath != null) {
...
} else {
...
//注释1
ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
}
}
在注释1处调用了ZygoteInit的zygoteInit方法，代码如下所示：
//路径：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
public static final void zygoteInit(int targetSdkVersion, String[] argv,
ClassLoader classLoader) throws Zygote.MethodAndArgsCaller {
...
//注释1
ZygoteInit.nativeZygoteInit();
//注释2
RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
}
private static final native void nativeZygoteInit();
在注释1处调用nativeZygoteInit方法来创建Binder线程池。注释2处调用RuntimeInit的applicationInit方法，代码如下所示：
//路径：/frameworks/base/core/java/com/android/internal/os/RuntimeInit.java
protected static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
throws Zygote.MethodAndArgsCaller {
...
invokeStaticMain(args.startClass, args.startArgs, classLoader);
}
applicationInit方法中调用了invokeStaticMain方法，如下所示：
//路径：/frameworks/base/core/java/com/android/internal/os/RuntimeInit.java
private static void invokeStaticMain(String className, String[] argv, ClassLoader classLoader)
throws Zygote.MethodAndArgsCaller {
Class<?> cl;
try {
//注释1
cl = Class.forName(className, true, classLoader);
} catch (ClassNotFoundException ex) {
...
}
Method m;
try {
//注释2
m = cl.getMethod("main", new Class[] { String[].class });
} catch (NoSuchMethodException ex) {
...
} catch (SecurityException ex) {
...
}
...
//注释3
throw new Zygote.MethodAndArgsCaller(m, argv);
}
在注释1处通过反射获取SystemServer类，这里的className值是com.android.server.SystemServer，从前面ZygoteInit的startSystemServer方法中可以发现，代码如下所示：
//路径：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
private static boolean startSystemServer(String abiList, String socketName, ZygoteServer zygoteServer)
throws Zygote.MethodAndArgsCaller, RuntimeException {
...
//注释1
String args[] = {
...
"com.android.server.SystemServer",
};
...
return true;
}
在传入的参数中可以看到传入的classname是com.android.server.SystemServer。
继续回到invokeStaticMain方法中，在注释2处获取SystemServer的main方法，最后在注释3处抛出一个异常对象Zgote.MethodAndArgsCaller，使用这种方式是为了清理堆栈，这样之后就会让加载SystemServer类的main方法觉得自己是进程的入口。
接下来看ZygoteInit的main函数捕获这个异常：
//路径：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
public static void main(String argv[]) {
...
try{
} catch (Zygote.MethodAndArgsCaller caller) {
//注释1
caller.run();
} catch (Throwable ex) {
...
}
...
}
注释1处捕获到Zygote.MethodAndArgsCaller异常后，调用它的run方法：
//路径：/frameworks/base/core/java/com/android/internal/os/Zygote.java
public final class Zygote {
...
public static class MethodAndArgsCaller extends Exception
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 {
//注释1
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);
}
}
}
}
MethodAndArgsCaller中的成员变量mMethod，这里指的就是SystemServer的main方法，在注释1处通过反射执行SystemServer的main方法。
进入SystemServer的main方法中：
//路径：/frameworks/base/services/java/com/android/server/SystemServer.java
public static void main(String[] args) {
new SystemServer().run();
}
main方法中调用了SystemServer的run方法：
//路径：/frameworks/base/services/java/com/android/server/SystemServer.java
private void run() {
try {
...
//创建消息Looper
Looper.prepareMainLooper();
//加载动态库libandroid_servers.so
System.loadLibrary("android_servers");
...
//创建系统的Context
createSystemContext();
//创建SystemServiceManager
mSystemServiceManager = new SystemServiceManager(mSystemContext);
mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
//保存SystemServiceManager
LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
//创建系统服务用的线程池
SystemServerInitThreadPool.get();
} finally {
traceEnd(); // InitBeforeStartServices
}
//开启服务
try {
traceBeginAndSlog("StartServices");
//启动引导服务
startBootstrapServices();
//启动核心服务
startCoreServices();
//启动其他服务
startOtherServices();
SystemServerInitThreadPool.shutdown();
} catch (Throwable ex) {
Slog.e("System", "******************************************");
Slog.e("System", "************ Failure starting system services", ex);
throw ex;
} finally {
traceEnd();
}
...
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
run方法中最重要的就是SystemServerManager，它的作用是用来对系统的服务进行创建、启动和生命周期管理，创建完SystemServerManager对象后，在后面的三个启动服务方法中会通过SystemServerManager来启动服务，startBootstrapServices方法是用于启动引导服务，引导服务包括ActivityManagerService、PowerManagerService、PackageManagerService、DeviceIdentifiersPolicyService等服务；startCoreServices方法用于启动核心服务，核心服务包括DropBoxManagerService、BatteryService、UsageStatsService以及WebViewUpdateService；startOtherServices方法用于启动其他服务，其他服务包括KeyChainSystemService、TelecomLoaderService、CameraService、AlarmManagerService等服务。
在启动其他服务中会通过ActivityManagerService的systemReady方法来启动Launcher。
838794-506ddad529df4cd4.webp.jpg
网友评论