本篇文章的内容中，我将要给大家介绍Android开发中最长见到的一个底层进程——Zygote进程，它是我们开发的所有APP进程的父进程。可以说，Android中所有的Java进程都是由Zygote进程fork出来的。
那面Zygote进程又是如何启动的呢？它的启动过程从init进程启动开始，到Zygote进程真正运行起来，并且进行相关初始化完成为止。
我们来详细分析下Zygote进程的启动过程。
说明：我们的源码是基于Android 8.1系统进行分析的。
init进程的启动
init进程是Android系统启动的第一个进程。我们来看init进程是如何启动的？（源码位置：system/core/init/init.cpp）
Linux内核启动的是从start_kernel函数开始的，start_kernel是所有Linux平台进入系统内核初始化后的入口函数，它主要完成一系列内核初始化相关工作，并且调用第一个用户进程——init进程。init启动之后，也就代表系统已经顺利地启动了Linux内核。
我们来看init进程的入口函数——init.cpp的main()方法：
int main(int argc, char** argv) {
if (!strcmp(basename(argv[0]), "ueventd")) {//1、如果文件名是"ueventd"，则执行守护进程ueventd的主函数ueventd_main()
return ueventd_main(argc, argv);
}
if (!strcmp(basename(argv[0]), "watchdogd")) {//2、如果文件名是"watchdogd"，则执行看门狗守护进程的主函数
return watchdogd_main(argc, argv);
}
……
add_environment("PATH", _PATH_DEFPATH);//3、设置环境变量
bool is_first_stage = (getenv("INIT_SECOND_STAGE") == nullptr);
if (is_first_stage) {
// Clear the umask.
umask(0);
//4、创建一些基本的目录，包括/dev、/porc、/sysfc等。同时把一些文件系统，如tmpfs、devpt、proc、sysfs等mount到项目的目录。
mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
mkdir("/dev/pts", 0755);
mkdir("/dev/socket", 0755);
mount("devpts", "/dev/pts", "devpts", 0, NULL);
#define MAKE_STR(x) __STRING(x)
mount("proc", "/proc", "proc", 0, "hidepid=2,gid=" MAKE_STR(AID_READPROC));
// Don't expose the raw commandline to unprivileged processes.
chmod("/proc/cmdline", 0440);
gid_t groups[] = { AID_READPROC };
setgroups(arraysize(groups), groups);
mount("sysfs", "/sys", "sysfs", 0, NULL);
mount("selinuxfs", "/sys/fs/selinux", "selinuxfs", 0, NULL);
mknod("/dev/kmsg", S_IFCHR | 0600, makedev(1, 11));
mknod("/dev/random", S_IFCHR | 0666, makedev(1, 8));
mknod("/dev/urandom", S_IFCHR | 0666, makedev(1, 9));
//5、SELinux初始化逻辑
// Set up SELinux, loading the SELinux policy.
selinux_initialize(true);
// We're in the kernel domain, so re-exec init to transition to the init domain now
// that the SELinux policy has been loaded.
if (selinux_android_restorecon("/init", 0) == -1) {
PLOG(ERROR) << "restorecon failed";
security_failure();
}
……
}
……
close(open("/dev/.booting", O_WRONLY | O_CREAT | O_CLOEXEC, 0000));//6、在/dev目录下创建一个空文件".booting"表示初始化正在进行。初始化结束后，这个文件会被删除。
// Propagate the kernel variables to internal variables
// used by init as well as the current required properties.
export_kernel_boot_props();//7、主要是调用property_init()函数来初始化Android的属性系统。
……
epoll_fd = epoll_create1(EPOLL_CLOEXEC);//8、调用epoll_create1创建epoll句柄，如果创建失败，则退出。
if (epoll_fd == -1) {
PLOG(ERROR) << "epoll_create1 failed";
exit(1);
}
signal_handler_init();//9、调用signal_handler_init()函数，主要是装载进程信号处理器。当子进程被kill之后，会在父进程接受一个信号。防止称为僵尸进程的子进程占用程序表的空间。
……
//10、解析init.rc文件
std::string bootscript = GetProperty("ro.boot.init_rc", "");
if (bootscript.empty()) {
parser.ParseConfig("/init.rc");
parser.set_is_system_etc_init_loaded(
parser.ParseConfig("/system/etc/init"));
parser.set_is_vendor_etc_init_loaded(
parser.ParseConfig("/vendor/etc/init"));
parser.set_is_odm_etc_init_loaded(parser.ParseConfig("/odm/etc/init"));
} else {
parser.ParseConfig(bootscript);
parser.set_is_system_etc_init_loaded(true);
parser.set_is_vendor_etc_init_loaded(true);
parser.set_is_odm_etc_init_loaded(true);
}
……
}执行过程如上，主要步骤我们通过注释可以清楚的了解到。
init进程启动过程中，会执行init.rc脚本文件（位置： /system/core/rootdir/init.rc）。它通过解析init.rc脚本来构建出系统的初始形态，解析init.rc会把一条条命令映射到内存中，然后依次启动。init.rc里面的顺序大致顺序如下：on early-init -> init -> late-init -> boot。
其中，init.rc会执行Zygote相关的启动脚本。所以说，Zygote进程是Linux系统的init进程通过解析配置脚本来进行启动的。脚本位置：/system/core/rootdir/init.zygote64.rc （64位）。
Zygote进程
通常，子进程被fork出来后，会继续执行系统调用exec，exec将用一个新的可执行文件的内容替换当前进程的代码段、数据段、堆和栈段。Fork加exec 是Linux启动应用的标准做法，init进程也是这样来启动的各种服务的。
Zygote创建应用程序时却只使用了fork，没有调用exec。Zygote初始化时会创建创建虚拟机，同时把需要的系统类库和资源文件加载到内存里面。Zygote fork出子进程后，这个子进程也继承了能正常工作的虚拟机和各类系统资源，接下来子进程只需要装载APK文件的字节码文件就可以运行了。这样应用程序的启动时间就会大大缩短。
init.rc脚本
我们来看init.rc脚本是如何启动Zygote进程的：
import /init.${ro.zygote}.rc //这里通过ro.zygote属性来控制启动不同版本的Zyogte进程。例如，ro.zygote=zygote64_32（zygote32/zygote32_64/zygote64
）
……
on late-init
# Now we can start zygote for devices with file based encryption
trigger zygote-start
……
# It is recommended to put unnecessary data/ initialization from post-fs-data
# to start-zygote in device's init.rc to unblock zygote start.
on zygote-start && property:ro.crypto.state=unencrypted
# A/B update verifier that marks a successful boot.
exec_start update_verifier_nonencrypted
start netd
start zygote
start zygote_secondary
on zygote-start && property:ro.crypto.state=unsupported
# A/B update verifier that marks a successful boot.
exec_start update_verifier_nonencrypted
start netd
start zygote
start zygote_secondary
on zygote-start && property:ro.crypto.state=encrypted && property:ro.crypto.type=file
# A/B update verifier that marks a successful boot.
exec_start update_verifier_nonencrypted
start netd
start zygote
start zygote_secondary
……我们可以看到，Zygote进程是通过init.rc脚本，在init进程中启动的（以service的方式启动），详细过程后面会讲到。
另外，在init.rc中，我们可以看到anr文件的权限设置：
mkdir /data/anr 0775 system system这里可以看到其实anr文件的目录其实对我们正常应用的APP是开放了rx权限（读、执行权限），但是非系统应用在Android 5.0之后就读取不到anr日志了，这个原因是因为在Android5.0之后，Android默认开启了SELinux权限控制。
ro.zygote变量
我们看到，脚本文件使用了另一个.rc文件，文件名称使用了ro.zygote变量，它的值有四种：
-
zygote32
-
zygote32_64
-
zygote64
-
zygote64_32
分别对应了4个.rc文件（在init.rc同目录下）：
-
init.zygote32
-
init.zygote64
-
init.zygote32_64
-
init.zygote64_32
为什么会有4个Zygote脚本文件呢？
这其实代表了Andorid系统支持4种运行模式：
-
纯32位模式：属性ro.zygote的值为zygote32
-
混32位模式(即32位为主，64位为辅)模式：属性ro.zygote的值为zygote32_64
-
纯64位模式：属性ro.zygote的值为zygote64
-
混64位模式(即 64位为主，32位为辅)模式：属性ro.zygote值为zygote64_32
Zygote进程的脚本文件
Zygote对应的配置脚本文件，描述了init该如何启动Zygote进程。
我们以64位CPU架构的脚本文件init.zygote64.rc作为示例：
service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server
class main
priority -20
user root
group root readproc
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
onrestart restart wificond
writepid /dev/cpuset/foreground/tasks它使用的是Android init配置脚本的语法，我们重点关注第一行内容：
-
service zygote：它告诉init进程，我们现在要配置一个名为zygote的服务（这里的服务是init内部的概念）。
-
/system/bin/app_process64：指明zygote服务对应的二进制文件的路径。init进程会fork一个子进程来运行指定的程序。对应zygote而言，这个程序就是/system/bin/app_process。
-
-Xzygote /system/bin --zygote --start-system-server：传递给app_process的启动参数。
当init进程真的启动zygote服务的时候，就会走到service_start()函数（init.cpp）。
下面我们来看Zygote真正的启动代码。
Zygote进程启动过程
Zygote进程的启动，涉及到了init.cpp、service.cpp、app_main.cpp以及脚本文件init.rc、init.zygote64.rc等文件。详细过程如图：
启动过程中的相关类及类的功能如下：
init.cpp
-
初始化相关配置。
-
通过handle_control_message()监听消息，执行Zygote服务。
-
调用service.cpp的Restart()方法。
service.cpp
-
调用Start()方法。
-
fork Zygote进程。
app_main.cpp
-
Zygote进程的入口函数main()
-
创建AppRuntime对象
-
调用AppRuntime对象的start方法
AndroidRuntime.cpp
-
AppRuntime的start方法实际指向AndroidRuntime的start方法
-
创建了一个JniInvocation的实例，并且调用它的成员函数init来初始化JNI环境
-
执行startVm，创建虚拟机及其对应的JNI接口
-
执行startReg，注册JNI函数
-
执行env.CallStaticVoidMethod调用到Java层，初始化Zygote进程
Zygoteinit.java
-
执行main方法
-
调用ZygoteServier的registerServerSocket(socketName)方法注册Zygote的socket监听接口，用来启动应用程序的消息
-
调用preload()方法装载系统资源，包括系统预加载类、Framework资源和openGL的资源。这样当程序被fork处理后，应用的进程内已经包含了这些系统资源，大大节省了应用的启动时间。
-
调用forkSystemServer()方法启动SystemServer进程
-
调动runSelectLoop方法来监听和处理启动应用的请求
app_main.cpp的main函数
我们来看重点来看下app_main.cpp的main函数：
int main(int argc, char* const argv[])
{
if (!LOG_NDEBUG) {
String8 argv_String;
for (int i = 0; i < argc; ++i) {
argv_String.append("\"");
argv_String.append(argv[i]);
argv_String.append("\" ");
}
ALOGV("app_process main with argv: %s", argv_String.string());
}
AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));//1、创建AppRuntime对象
// Process command line arguments
// ignore argv[0]
argc--;
argv++;
……
bool known_command = false;
//****************2、从init.rc传入的参数 为 -Xzygote /system/bin --zygote --start-system-server
int i;
for (i = 0; i < argc; i++) {
if (known_command == true) {
runtime.addOption(strdup(argv[i]));
// The static analyzer gets upset that we don't ever free the above
// string. Since the allocation is from main, leaking it doesn't seem
// problematic. NOLINTNEXTLINE
ALOGV("app_process main add known option '%s'", argv[i]);
known_command = false;
continue;
}
for (int j = 0;
j < static_cast<int>(sizeof(spaced_commands) / sizeof(spaced_commands[0]));
++j) {
if (strcmp(argv[i], spaced_commands[j]) == 0) {
known_command = true;
ALOGV("app_process main found known command '%s'", argv[i]);
}
}
if (argv[i][0] != '-') {
break;
}
if (argv[i][1] == '-' && argv[i][2] == 0) {
++i; // Skip --.
break;
}
runtime.addOption(strdup(argv[i]));
// The static analyzer gets upset that we don't ever free the above
// string. Since the allocation is from main, leaking it doesn't seem
// problematic. NOLINTNEXTLINE
ALOGV("app_process main add option '%s'", argv[i]);
}
// Parse runtime arguments. Stop at first unrecognized option.
bool zygote = false;
bool startSystemServer = false;
bool application = false;
String8 niceName;
String8 className;
//****************3、将上面的内容赋给相应的变量
++i; // Skip unused "parent dir" argument.
while (i < argc) {
const char* arg = argv[i++];
if (strcmp(arg, "--zygote") == 0) {
zygote = true;
niceName = ZYGOTE_NICE_NAME;//niceName将被设置为app_process的进程名，32位机为“zygote”，64位机为“zygote64”。
} 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;
}
}
//*************4、准备启动ZygoteInit类或者RuntimeInit类，这里根据类名是否存在为空，来区别是非zyoget模式和zyoget模式.
Vector<String8> args;
if (!className.isEmpty()) {
// We're not in zygote mode, the only argument we need to pass
// to RuntimeInit is the application argument.
//
// The Remainder of args get passed to startup class main(). Make
// copies of them before we overwrite them with the process name.
args.add(application ? String8("application") : String8("tool"));
runtime.setClassNameAndArgs(className, argc - i, argv + i);
if (!LOG_NDEBUG) {
String8 restOfArgs;
char* const* argv_new = argv + i;
int argc_new = argc - i;
for (int k = 0; k < argc_new; ++k) {
restOfArgs.append("\"");
restOfArgs.append(argv_new[k]);
restOfArgs.append("\" ");
}
ALOGV("Class name = %s, args = %s", className.string(), restOfArgs.string());
}
} else {
// We're in zygote mode.
maybeCreateDalvikCache();
if (startSystemServer) {
args.add(String8("start-system-server"));
}
char prop[PROP_VALUE_MAX];
if (property_get(ABI_LIST_PROPERTY, prop, NULL) == 0) {
LOG_ALWAYS_FATAL("app_process: Unable to determine ABI list from property %s.",
ABI_LIST_PROPERTY);
return 11;
}
String8 abiFlag("--abi-list=");
abiFlag.append(prop);
args.add(abiFlag);
// In zygote mode, pass all remaining arguments to the zygote
// main() method.
for (; i < argc; ++i) {
args.add(String8(argv[i]));
}
}
//5、进程的名称修改
if (!niceName.isEmpty()) {
runtime.setArgv0(niceName.string(), true /* setProcName */);
}
//6、启动Java类
if (zygote) {
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.");
}
}主要过程如下：
1、创建AppRuntime对象。
2、处理从init.rc传入的参数 为 -Xzygote /system/bin --zygote --start-system-server，传递给AppRuntime对象。
-
-Xzygote是传递给虚拟机的参数
-
/system/bin 是 parent dir(程序运行目录)
-
--zygote表示以zygote模式启动
3、将上面的内容赋给相应的变量
以-Xzygote /system/bin --zygote --start-system-server为例，结果如下：
-
变量 parentDir 等于/system/bin
-
变量 niceName 等于 zyoget
-
变量 startSystemServer 等于 true
-
变量 zygote 等于 true
4、准备启动ZygoteInit类或者RuntimeInit类，这里根据类名是否存在为空，来区别是非zyoget模式和zyoget模式.
5、如果niceName不为空，则将本进程的名称修改为参数** --nice-name** 指定的字符串。缺省的情况下，niceName 的值为"zygote"或者"zygote64"。其中set_process_name函数用来改变进程的mi9ngcheng。setArgv0函数是用来替换启动参数串中的"app_process"为参数。
6、启动Java类，如果启动参数带有 "--zygote"。则执行ZygoteInit。
分三种情况：
-
zygote 模式，即启动ZygoteInit
-
非zygote 模式，即启动RuntimeInit
-
以上两种均不是
Java层的ZygoteInit的main()方法
我们再来分析下上述过程中的ZygoteInit的main()方法：
public static void main(String argv[]) {
ZygoteServer zygoteServer = new ZygoteServer();//1、创建ZygoteServer对象
// Mark zygote start. This ensures that thread creation will throw
// an error.
ZygoteHooks.startZygoteNoThreadCreation();
// Zygote goes into its own process group.
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"))) {
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();
//***********2、解析参数
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])) {
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.");
}
//3、调用registerZygoteSocket(socketName)方法注册Zygote的socket监听接口，用来启动应用程序的消息
zygoteServer.registerServerSocket(socketName);
// 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);//4、调用preload()方法装载系统资源，包括系统预加载类、Framework资源和openGL的资源。这样当程序被fork处理后，应用的进程内已经包含了这些系统资源，大大节省了应用的启动时间。
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.
Zygote.nativeUnmountStorageOnInit();
// Set seccomp policy
Seccomp.setPolicy();
ZygoteHooks.stopZygoteNoThreadCreation();
if (startSystemServer) {
Runnable r = forkSystemServer(abiList, socketName, zygoteServer);//5、启动SystemServer进程
// {@code r == null} in the parent (zygote) process, and {@code r != null} in the
// child (system_server) process.
if (r != null) {
r.run();
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);//6、调动runSelectLoop方法来监听和处理启动应用的请求
} catch (Throwable ex) {
Log.e(TAG, "System zygote died with exception", ex);
throw ex;
} finally {
zygoteServer.closeServerSocket();
}
// We're in the child process and have exited the select loop. Proceed to execute the
// command.
if (caller != null) {
caller.run();
}
}1、创建ZygoteServer对象。
2、解析参数。
3、调用registerZygoteSocket(socketName)方法注册Zygote的socket监听接口，用来启动应用程序的消息。
为zygote命令注册一个socket连接的服务端socket。init进程会根据这条选项来创建一个"AF_UNIX"socket，并把它的句柄放到环境变量"ANDROID_SOCKET_zygote"中。同理我们也可以这样得到句柄，得到句柄后，new了一个FileDescriptor对象，并通过调用setInt$()方法来设置其值。最后new了LocalServerSocket对象，来创建本地的服务socket，并将其值保存在全局变量sServerSocket中。
4、调用preload()方法预加载资源。
为了加快应用程序的启动，Android把系统公用的Java类和一部分Framework的资源保存在zygote中了，这样就可以保证zygote进程fork子进程的是共享的。
-
preloadClasses()：预加载Java类
-
preloadResources()：预加资源
-
preloadOpenGL()：预加载OpenGL资源
-
preloadSharedLibraries()：预计加载共享库
-
preloadTextResources()：预加载文本资源
-
WebViewFactory.prepareWebViewInZygote()：初始化WebView
5、启动SystemServer进程。
-
为fork准备参数parsedArgs
-
调用Zygote.forkSystemServer()方法来创建system_server
-
调用handleSystemServerProcess()方法执行system_server的剩余工作
6、调动runSelectLoop方法来监听和处理启动应用的请求。
ZygoteInit类的main()方法调用runSelectLoop()方法来监听和处理启动应用的请求。
执行zygote进程的循环。当来一个新的连接请求时，则建立接受并建立连接，并在连接中读取请求的命令。
至此，Init进程以及Zygote进程的启动过程就分析完成了。
