概述
在Android系统中，DVM(Dalvik 虚拟机和ART、应用程序进程以及运行系统的关键服务SystemServer进程都是由Zygote进程来创建的。通过fork（复制进程）的形式来创建应用程进程和SystemServer进程，由于Zygote进程在启动时会创建DVM或者ART，因此通过 fork而创建的应用程序进程和SystemServer进程可以在内部获取DVM或者ART实例副本。
Zygote进程是init进程启动时创建的，Zygote进程的名称并不是叫zygote，而是叫app_process，这个名称是在Android.mk中定义的，Zygote进程启动后，Linux 系统下的petri 系统会调用app_process ，将其名称换成了“zygote ”。
Zygote启动脚本
init进程启动后，会解析init.rc文件，然后创建和加载service字段指定的进程。在init.rc 文件中采用了Import类型语句来引人Zygote启动脚本，这些启动脚本都是由Android初始化语言来编写的：
import/init.${ro.zygote}.rc
init.rc不会直接引入一个固定的文件，而是根据属性ro.zygote的内容来引入不同的文件。
Zygote有32位和64位的区别，所以在这里用ro.zygote属性来控制使用不同的Zygote启动脚本，从而也就启动了不同版本的Zygote进程，ro.zygote属性的取值有以下4种:
- init.zygote32.rc
- init.zygote32_64.rc
- init.zygote64.rc
- init.zygote64_32.rc
这些Zygote启动脚本都放在system/core/rootdir目录中。现在的主流厂家基本使用zygote64_32，因此，我们的rc文件为 init.zygote64_32.rc。
Zygote 进程启动过程
app_main.cpp的main函数
init进程启动Zygote时主要是调用app_main.cpp的main函数中的AppRuntime的start 方法来启动Zygote进程的，先从app_ main.cpp的main函数开始分析：
/frameworks/base/cmds/app_process/app_main.cpp
int main(int argc, char* const argv[]){
...
while (i < argc) {
const char* arg = argv[i++];
if (strcmp(arg, "--zygote") == 0) {// 注释1
// 如果当前运行在 Zygote 进程中，则将 zygote 设置为 true
zygote = true;// 注释2
// 对于64位系统nice_name为zygote64; 32位系统为zygote
niceName = ZYGOTE_NICE_NAME;
} else if (strcmp(arg, "--start-system-server") == 0) {// 注释3
// 如果当前运行在 SystemServer 进程中，则将 startSystemServer 设置为 true
startSystemServer = true;// 注释4
} else if (strcmp(arg, "--application") == 0) {
//启动进入独立的程序模式
application = true;
} else if (strncmp(arg, "--nice-name=", 12) == 0) {
//niceName 为当前进程别名，区别abi型号
niceName.setTo(arg + 12);
} else if (strncmp(arg, "--", 2) != 0) {
className.setTo(arg);
break;
} else {
--i;
break;
}
}
...
if (!niceName.isEmpty()) {
// 设置昵称zygote\zygote64，之前的名称是app_process
runtime.setArgv0(niceName.string(), true /* setProcName */);
}
if (zygote) {// 注释5
// 如果运行在Zygote进程中，则加载ZygoteInit
runtime.start("com.android.internal.os.ZygoteInit", args, zygote);// 注释6
} else if (className) {
//如果是application启动模式，则加载RuntimeInit
runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
} else {
//没有指定类名或zygote，参数错误
fprintf(stderr, "Error: no class name or --zygote supplied.\n");
app_usage();
LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
}
}
Zygote进程都是通过fork自身来创建子进程的，这样Zygote进程以及它的子进程都可以进入app_ main.cpp的main函数，因此main函数中为了区分当前运行在哪个进程中，会在注释1处判断参数arg中是否包含了–zygote，如果包含了则说明main函数是运行在Zygote 进程中的并在注释2处将zygote置为ture。在注释3处判断参数arg 中是否包含了“ start-system server”，如果包含了则说明main函数是运行在SystemServer进程中的并在注释4 处将startSystemServer设置为true。在注释5处，如果zygote为true，就说明当前运行在 Zygote 进程中，就会调用注释6处的AppRuntime的start函数，来加载虚拟机并进入JAVA世界。
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, primary_zygote) != 0) {
return;
}
onVmCreated(env);
// 为Java虚拟机注册JNI方法
if (startReg(env) < 0) {//2
ALOGE("Unable to register all android natives\n");
return;
}
jclass stringClass;
jobjectArray strArray;
jstring classNameStr;
stringClass = env->FindClass("java/lang/String");
assert(stringClass != NULL);
strArray = env->NewObjectArray(options.size() + 1, stringClass, NULL);
assert(strArray != NULL);
//从app_main的main函数得知className为com.android.internal.os.Zygoteinit
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);
}
// classNarne “.”替换为“/”
char* slashClassName = toSlashClassName(className != NULL ? className : "");
//找到Zygoteinit类
jclass startClass = env->FindClass(slashClassName);
if (startClass == NULL) {
ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
/* keep going */
} else {
// 找到ZygoteInit的main方法
jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
"([Ljava/lang/String;)V");//6
if (startMeth == NULL) {
ALOGE("JavaVM unable to find main() in '%s'\n", className);
/* keep going */
} else {
// 通过JNI调用Zygoteinit的main 方法
env->CallStaticVoidMethod(startClass, startMeth, strArray);
#if 0
if (env->ExceptionCheck())
threadExitUncaughtException(env);
#endif
}
}
//释放相应对象的内存空间
free(slashClassName);
...
}
从以上代码可以看出，通过JNI调用Zygotelnit的main方法。因为Zygotelnit的main方法是由Java语言编写的，当前的运行逻辑在Native中，这就需要通过JNI调用Java。这样Zygote就从Native进入了Java框架层。start()函数主要做了三件事情：1.调用startVm函数开启虚拟机。2.调用startReg注册JNI方法。3.使用JNI把Zygote进程启动起来。
ZygoteInit的main函数
通过JNI调用ZygoteInit的main函数后，Zygote便进入了Java框架层，此前没有任何代码进入过Java框架层，换句换说Zygote开创了Java框架层。
frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
public static void main(String argv[]) {
// 1. 创建ZygoteServer
ZygoteServer zygoteServer = null;
// 调用native函数，确保当前没有其它线程在运行
ZygoteHooks.startZygoteNoThreadCreation();
try {
// 设置pid为0，Zygote进入自己的进程
Os.setpgid(0, 0);
} catch (ErrnoException ex) {
throw new RuntimeException("Failed to setpgid(0,0)", ex);
}
Runnable caller;
try{
...
boolean startSystemServer = false;
String zygoteSocketName = "zygote";
String abiList = null;
boolean enableLazyPreload = false;
// 2. 解析app_main.cpp - start()传入的参数
for (int i = 1; i < argv.length; i++) {
if ("start-system-server".equals(argv[i])) {
//启动zygote时，才会传入参数：start-system-server
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)) {
zygoteSocketName = argv[i].substring(SOCKET_NAME_ARG.length());
} else {
throw new RuntimeException("Unknown command line argument: " + argv[i]);
}
}
// 根据传入socket name来决定是创建socket还是zygote_secondary
final boolean isPrimaryZygote = zygoteSocketName.equals(Zygote.PRIMARY_SOCKET_NAME);
...
// 在第一次zygote启动时，enableLazyPreload为false，执行preload
if (!enableLazyPreload) {
bootTimingsTraceLog.traceBegin("ZygotePreload");
EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,
SystemClock.uptimeMillis());
// 3.预加载类和资源(详解下文1)
preload(bootTimingsTraceLog);
EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,
SystemClock.uptimeMillis());
bootTimingsTraceLog.traceEnd(); // ZygotePreload
}
...
// 4.调用ZygoteServer构造函数，创建socket.(详解下文2)
zygoteServer = new ZygoteServer(isPrimaryZygote);
if (startSystemServer) {
//5.fork出systemServer(详解下文3)
Runnable r = forkSystemServer(abiList, zygoteSocketName, zygoteServer);
// 启动SystemServer
if (r != null) {
r.run();// 调用SystemServer 的main 方法
return;
}
}
//6. zygote进程进入无限循环，等待AMS请求(详解下文4)
caller = zygoteServer.runSelectLoop(abiList);
}catch (Throwable ex) {
Log.e(TAG, "System zygote died with exception", ex);
throw ex;
} finally {
if (zygoteServer != null) {
zygoteServer.closeServerSocket();
}
}
// 7.在子进程中退出了选择循环。继续执行命令
if (caller != null) {
caller.run();
}
}
Zygotelnit的main方法主要做了4件事：1.创建一个Server端的Socket。2.预加载类和资源。3. 启动SystemServer进程。 4.等待AMS请求创建新的应用程序进程。
详解1：preload()
- 预加载
在Zygote进程启动的时候就加载，这样系统只在zygote执行一次加载操作，所有APP用到该资源不需要再重新加载，减少资源加载时间，加快了应用启动速度，一般情况下，系统中App共享的资源会被列为预加载资源。
Zygote fork子进程时，根据fork的copy-on-write机制可知，有些类如果不做改变，甚至都不用复制，子进程可以和父进程共享这部分数据，从而省去不少内存的占用。
- 预加载的原理
Zygote进程启动后将资源读取出来，保存到Resources一个全局静态变量中，下次读取系统资源的时候优先从静态变量中查找。
- 源码
static void preload(TimingsTraceLog bootTimingsTraceLog) {
...
// 获取字符集转换资源等
beginPreload();
// 预加载类的列表
preloadClasses();
cacheNonBootClasspathClassLoaders();
// 加载图片、颜色等资源文件，部分定义在 /frameworks/base/core/res/res/values/arrays.xml中
preloadResources();
nativePreloadAppProcessHALs();
maybePreloadGraphicsDriver();
// 加载 android、compiler_rt、jnigraphics等library
preloadSharedLibraries();
// 用于初始化文字资源
preloadTextResources();
// 用于初始化webview
WebViewFactory.prepareWebViewInZygote();
// 预加载完成
endPreload();
warmUpJcaProviders();
sPreloadComplete = true;
}
详解2：ZygoteServer()
frameworks/base/core/java/com/android/internal/os/ZygoteServer.java
private LocalServerSocket mZygoteSocket;
private LocalServerSocket mUsapPoolSocket;
ZygoteServer(boolean isPrimaryZygote) {
mUsapPoolEventFD = Zygote.getUsapPoolEventFD();
if (isPrimaryZygote) {
// 创建socket，并获取socket对象，socketname： zygote
mZygoteSocket = Zygote.createManagedSocketFromInitSocket(Zygote.PRIMARY_SOCKET_NAME);
// 创建socket，并获取socket对象，socketname：usap_pool_primary
mUsapPoolSocket =
Zygote.createManagedSocketFromInitSocket(
Zygote.USAP_POOL_PRIMARY_SOCKET_NAME);
} else {
// 创建socket，并获取socket对象，socketname：zygote_secondary
mZygoteSocket = Zygote.createManagedSocketFromInitSocket(Zygote.SECONDARY_SOCKET_NAME);
// 创建socket，并获取socket对象，socketname：usap_pool_secondary
mUsapPoolSocket =
Zygote.createManagedSocketFromInitSocket(
Zygote.USAP_POOL_SECONDARY_SOCKET_NAME);
}
mUsapPoolSupported = true;
fetchUsapPoolPolicyProps();
}
frameworks/base/core/java/com/android/internal/os/Zygote.java
static LocalServerSocket createManagedSocketFromInitSocket(String socketName) {
int fileDesc;
final String fullSocketName = ANDROID_SOCKET_PREFIX + socketName;
try {
// 在进程被创建时，就会创建对应的文件描述符，并加入到环境变量中,并取出对应的环境变量
String env = System.getenv(fullSocketName);
fileDesc = Integer.parseInt(env);
} catch (RuntimeException ex) {
throw new RuntimeException("Socket unset or invalid: " + fullSocketName, ex);
}
try {
FileDescriptor fd = new FileDescriptor();
// 获取zygote socket的文件描述符
fd.setInt$(fileDesc);
return new LocalServerSocket(fd);// 创建Socket的本地服务端
} catch (IOException ex) {
throw new RuntimeException(
"Error building socket from file descriptor: " + fileDesc, ex);
}
}
ZygoteServer 构造函数初始化时，根据传入的参数，利用LocalServerSocket创建了4个本地服务端的socket，用来建立连接，分别是：zygote、usap_pool_primary、zygote_secondary、usap_pool_secondary。
详解3：forkSystemServer
frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
private static Runnable forkSystemServer(String abiList, String socketName, ZygoteServer zygoteServer) {
...
//来创建args数组，这个数组用来保存启动SystemServer 的启动参数
String args[] = {
"--setuid=1000",
"--setgid=1000",
"--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1023,"
+ "1024,1032,1065,3001,3002,3003,3006,3007,3009,3010,3011",
"--capabilities=" + capabilities + "," + capabilities,
"--nice-name=system_server",
"--runtime-args",
"--target-sdk-version=" + VMRuntime.SDK_VERSION_CUR_DEVELOPMENT,
"com.android.server.SystemServer",
};
ZygoteArguments parsedArgs = null;
int pid;
try {
//将args数组封装成Arguments对象，并供下面的SystemServer 函数调用
parsedArgs = new ZygoteArguments(args);
Zygote.applyDebuggerSystemProperty(parsedArgs);
Zygote.applyInvokeWithSystemProperty(parsedArgs);
if (Zygote.nativeSupportsTaggedPointers()) {
/* Enable pointer tagging in the system server. Hardware support for this is present
* in all ARMv8 CPUs. */
parsedArgs.mRuntimeFlags |= Zygote.MEMORY_TAG_LEVEL_TBI;
}
/* Enable gwp-asan on the system server with a small probability. This is the same
* policy as applied to native processes and system apps. */
parsedArgs.mRuntimeFlags |= Zygote.GWP_ASAN_LEVEL_LOTTERY;
if (shouldProfileSystemServer()) {
parsedArgs.mRuntimeFlags |= Zygote.PROFILE_SYSTEM_SERVER;
}
// 创建一个子进程，也就是 SystemServer 进程
pid = Zygote.forkSystemServer(
parsedArgs.mUid, parsedArgs.mGid,
parsedArgs.mGids,
parsedArgs.mRuntimeFlags,
null,
parsedArgs.mPermittedCapabilities,
parsedArgs.mEffectiveCapabilities);
} catch (IllegalArgumentException ex) {
throw new RuntimeException(ex);
}
// 当前代码逻辑运行在子进程system_server中
if (pid == 0) {
// 处理32_64和64_32的情况
if (hasSecondZygote(abiList)) {
// /需要等待第二个Zygote创建完成
waitForSecondaryZygote(socketName);
}
// 关闭连接
zygoteServer.closeServerSocket();
// 处理 SystemServer进程
return handleSystemServerProcess(parsedArgs);
}
return null;
}
调用Zygote的forkSystemServer方法，其内部会调用nativeForkSystemServer这个Native方法，nativeForkSystemServer方法最终会通过fork函数在当前进程创建一个子进程，也就是SystemServer进程，如果forkSystemServer方法返回的pid的值为0，就表示当前的代码运行在新创建的子进程中。
详解4：runSelectLoop
frameworks/base/core/java/com/android/internal/os/ZygoteServer.java
Runnable runSelectLoop(String abiList) {
ArrayList<FileDescriptor> socketFDs = new ArrayList<>();
ArrayList<ZygoteConnection> peers = new ArrayList<>();
// 该Socket的fd字段的值并添加到socketFDs列表
socketFDs.add(mZygoteSocket.getFileDescriptor());
// 无限循环等待AMS的请求
while (true) {
...
int pollReturnValue;
try {
// 等待事件到来
pollReturnValue = Os.poll(pollFDs,pollTimeoutMs);
} catch (ErrnoException ex) {
throw new RuntimeException("poll failed", ex);
}
...
// 倒序处理，即优先处理已建立链接的信息，后处理新建链接的请求
while (--pollIndex >= 0) {
if (pollIndex == 0) {
// 收到新的建立通信的请求，建立通信连接
ZygoteConnection newPeer = acceptCommandPeer(abiList);
peers.add(newPeer);
//加入到peers和fds, 即下一次也开始监听
socketFDs.add(newPeer.getFileDescriptor());
} else if (pollIndex < usapPoolEventFDIndex) {
// Session socket accepted from the Zygote server socket
try {
//有socket连接，创建ZygoteConnection对象,并添加到fds
ZygoteConnection connection = peers.get(pollIndex);
final Runnable command = connection.processOneCommand(this);
}
}
...
}
}
Zygote进程启动总结
- 创建AppRuntime并调用其start方法，启动Zygote进程。
- 创建Java虚拟机并为Java虚拟机注册JNI方法。
- 通过JNI调用Zygotelnit的main函数进入Zygote的Java框架层。
- 通过ZygoteServer创建服务端Socket，预加载类和资源，并通过runSelectLoop方法等待AMS的请求来创建新的应用程序进程。
- 启动SystemServer进程。
扫一扫
2693
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
