文章目录
概述
我们都知道，Android系统存在着两个完全不同的世界：
1. Java世界，Google提供的SDK编写出来的程序大部分都是针对这个世界的。在这个世界中运行的程序都是基于Dalvik虚拟机的java程序。
2. Native世界，也就是用Native语言C或者C++开发的程序，例如采用NDK开发的程序。
于是便有了这个疑问：
Android系统是基于linux内核构建的，那么最早肯定是native世界，可java世界是什么时候开始被创建出来的呢？
带着这个疑问，我们今天就来剖析下zygote进程的实现原理。
zygote分析
zygote本身是一个Native的应用程序，在前面对init进程的分析中，我们知道，zygote是系统在刚开始初始化时，init进程根据init.rc配置文件fork出来的子进程，映像路径为/system/bin/app_process。所以，zygote最初的名字叫“app_process”，在程序运行过程中，app_process通过Linux下的prctl系统调用将自己的名字改成了“zygote”，所以我们通过ps命令看到的进程名是“zygote”。
Zygote的原型app_process所对应的源文件为frameworks\base\cmds\app_process\App_main.cpp。相应main函数如下：
int main(int argc, char* const argv[])
{
…..
/*
Init.rc中的zygote启动参数：
-Xzygote /system/bin --zygote --start-system-server
*/
mArgC = argc;
mArgV = argv;
mArgLen = 0;
for (int i=0; i<argc; i++) {
mArgLen += strlen(argv[i]) + 1;
}
mArgLen--;
// 定义一个AppRuntime的对象runtime
AppRuntime runtime;
const char* argv0 = argv[0];
argc--;
argv++;
// 添加vm启动参数
int i = runtime.addVmArguments(argc, argv);
// 开始解析运行时参数
bool zygote = false;
bool startSystemServer = false;
bool application = false;
const char* parentDir = NULL;
const char* niceName = NULL;
const char* className = NULL;
while (i < argc) {
const char* arg = argv[i++];
if (!parentDir) {
parentDir = arg; // parentDir = /system/bin
} else if (strcmp(arg, "--zygote") == 0) {
zygote = true; // zygote确实也为true
niceName = "zygote";
} else if (strcmp(arg, "--start-system-server") == 0) {
startSystemServer = true; // 为true
} else if (strcmp(arg, "--application") == 0) {
application = true;
} else if (strncmp(arg, "--nice-name=", 12) == 0) {
niceName = arg + 12;
} else {
className = arg;
break;
}
}
if (niceName && *niceName) {
setArgv0(argv0, niceName);
// 通过prctl系统调用把自己的名字改成zygote
set_process_name(niceName);
}
runtime.mParentDir = parentDir;
if (zygote) {
/*
调用runtime的start函数，startSystemServer为true
参数1：“com.android.internal.os.ZygoteInit”
参数2：“start-system-server”
*/
runtime.start("com.android.internal.os.ZygoteInit",
startSystemServer ? "start-system-server" : "");
} else if (className) {
……
}
……
}
zygote的main函数主要做了两件事情：
1. app_process通过prctl系统调用把自己的名字改成zygote
2. AppRuntime通过start函数接着启动system_server
AppRuntime分析
接着来看看AppRuntime的实现。
class AppRuntime : public AndroidRuntime
{
……
}
AppRuntime是继承自AndroidRuntime的，主要重载了onVmCreated、onStarted、onZygoteInit和onExit函数。前面的代码runtime.start(…)，这个start函数使用的是基类AndroidRuntime的start，我们来分析一下它。
// 参数1：“com.android.internal.os.ZygoteInit”
// 参数2：“start-system-server”
void AndroidRuntime::start(const char* className, const char* options)
{
……
// 设置环境变量ANDROID_ROOT为"/system"
const char* rootDir = getenv("ANDROID_ROOT");
if (rootDir == NULL) {
rootDir = "/system";
if (!hasDir("/system")) {
LOG_FATAL("No root directory specified, and /android does not exist.");
return;
}
setenv("ANDROID_ROOT", rootDir, 1);
}
/* start the virtual machine */
JNIEnv* env;
if (startVm(&mJavaVM, &env) != 0) {
return;
}
……
/* Register android functions. */
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.
*/
jclass stringClass;
jobjectArray strArray;
jstring classNameStr;
jstring optionsStr;
stringClass = env->FindClass("java/lang/String");
assert(stringClass != NULL);
strArray = env->NewObjectArray(2, stringClass, NULL);
assert(strArray != NULL);
classNameStr = env->NewStringUTF(className);
assert(classNameStr != NULL);
env->SetObjectArrayElement(strArray, 0, classNameStr);
optionsStr = env->NewStringUTF(options);
env->SetObjectArrayElement(strArray, 1, optionsStr);
/*
* Start VM. This thread becomes the main thread of the VM, and will
* not return until the VM exits.
*/
/*
className本身为com.android.internal.os.ZygoteInit
toSlashClassName函数将className的.转换成为/，于是
转换之后为：com/android/internal/os/ZygoteInit
*/
char* slashClassName = toSlashClassName(className);
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");
if (startMeth == NULL) {
ALOGE("JavaVM unable to find main() in '%s'\n", className);
/* keep going */
} else {
/*
调用ZygoteInit类的main函数，此时将转到java世界开始执行
所以zygote进程相当于开创java世界的盘古
*/
env->CallStaticVoidMethod(startClass, startMeth, strArray);
#if 0
if (env->ExceptionCheck())
threadExitUncaughtException(env);
#endif
}
}
free(slashClassName);
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");
}
上面的代码逻辑不难，但是要从native层进入到java层开始执行需要煞费一番苦心，我们一一来分析。
创建虚拟机 - startVm
int AndroidRuntime::startVm(JavaVM** pJavaVM, JNIEnv** pEnv)
{
……
property_get("dalvik.vm.checkjni", propBuf, "");
if (strcmp(propBuf, "true") == 0) {
checkJni = true;
} else if (strcmp(propBuf, "false") != 0) {
/* property is neither true nor false; fall back on kernel parameter */
property_get("ro.kernel.android.checkjni", propBuf, "");
if (propBuf[0] == '1') {
checkJni = true;
}
}
…..
/*
* The default starting and maximum size of the heap. Larger
* values should be specified in a product property override.
*/
strcpy(heapstartsizeOptsBuf, "-Xms");
property_get("dalvik.vm.heapstartsize", heapstartsizeOptsBuf+4, "4m");
opt.optionString = heapstartsizeOptsBuf;
mOptions.add(opt);
strcpy(heapsizeOptsBuf, "-Xmx");
property_get("dalvik.vm.heapsize", heapsizeOptsBuf+4, "16m");
opt.optionString = heapsizeOptsBuf;
mOptions.add(opt);
// Increase the main thread's interpreter stack size for bug 6315322.
opt.optionString = "-XX:mainThreadStackSize=24K";
mOptions.add(opt);
……
/*
* Initialize the VM.
*
* The JavaVM* is essentially per-process, and the JNIEnv* is per-thread.
* If this call succeeds, the VM is ready, and we can start issuing
* JNI calls.
*/
if (JNI_CreateJavaVM(pJavaVM, pEnv, &initArgs) < 0) {
ALOGE("JNI_CreateJavaVM failed\n");
goto bail;
}
result = 0;
bail:
free(stackTraceFile);
return result;
}
这个函数主要是根据init进程初始化的时候解析的属性配置文件得到的数据来进行初始化VM虚拟机，包括设置jni check、heap size等等属性。最后，通过JNI_CreateJavaVM函数创建虚拟机。代码注释中写的也很清楚了，返回值pJavaVM一般是针对整个进程的，而pEnv是针对每个线程的。
注册JNI函数– startReg
前面已经调用startVm函数来创建虚拟机，下一步则需要给整个虚拟机注册一些常用的JNI函数。正是因为后续java世界用到的一些函数是采用native方式实现的，所以才需要提前注册这些函数。
/*
* Register android native functions with the VM.
*/
/*static*/ int AndroidRuntime::startReg(JNIEnv* env)
{
/*
* This hook causes all future threads created in this process to be
* attached to the JavaVM. (This needs to go away in favor of JNI
* Attach calls.)
*/
androidSetCreateThreadFunc((android_create_thread_fn) javaCreateThreadEtc);
ALOGV("--- registering native functions ---\n");
/*
* Every "register" function calls one or more things that return
* a local reference (e.g. FindClass). Because we haven't really
* started the VM yet, they're all getting stored in the base frame
* and never released. Use Push/Pop to manage the storage.
*/
env->PushLocalFrame(200);
if (register_jni_procs(gRegJNI, NELEM(gRegJNI), env) < 0) {
env->PopLocalFrame(NULL);
return -1;
}
env->PopLocalFrame(NULL);
return 0;
}
static int register_jni_procs(const RegJNIRec array[], size_t count, JNIEnv* env)
{
for (size_t i = 0; i < count; i++) {
if (array[i].mProc(env) < 0) {
return -1;
}
}
return 0;
}
上面的代码通过register_jni_procs函数注册JNI函数，其中gRegJNI是一个数组，如下：
static const RegJNIRec gRegJNI[] = {
REG_JNI(register_android_debug_JNITest),
REG_JNI(register_com_android_internal_os_RuntimeInit),
REG_JNI(register_android_os_SystemClock),
REG_JNI(register_android_util_EventLog),
REG_JNI(register_android_util_Log),
REG_JNI(register_android_util_FloatMath),
REG_JNI(register_android_text_format_Time),
REG_JNI(register_android_content_AssetManager),
REG_JNI(register_android_content_StringBlock),
……
}
看第一个例子吧：
int register_android_debug_JNITest(JNIEnv* env)
{
return jniRegisterNativeMethods(env, "android/debug/JNITest",
gMethods, NELEM(gMethods));
}
其实就是调用jniRegisterNativeMethods函数来注册android.debug.JNITest类的JNI函数。
进入Java世界
虚拟机创建完毕，JNI函数也注册好了，可以说是万事俱备只欠东风了。那么我们来看看，JAVA世界的入口到底在哪里呢？根据前面的分析可知，CallStaticVoidMethod函数最终会调用com.android.internal.os.ZygoteInit类的main函数，下面就来看看这个入口函数吧。
public static void main(String argv[]) {
try {
// Start profiling the zygote initialization.
SamplingProfilerIntegration.start();
// 注册zygote用的socket
registerZygoteSocket();
// 预加载资源和类
preload();
// Finish profiling the zygote initialization.
SamplingProfilerIntegration.writeZygoteSnapshot();
// Do an initial gc to clean up after startup
gc();
// Disable tracing so that forked processes do not inherit stale tracing tags from
// Zygote.
Trace.setTracingEnabled(false);
……
if (argv[1].equals("start-system-server")) {
startSystemServer();
} else if (!argv[1].equals("")) {
throw new RuntimeException(argv[0] + USAGE_STRING);
}
runSelectLoop(); // 等待事件发生
closeServerSocket();
} catch (MethodAndArgsCaller caller) {
caller.run(); // 这个很重要，后面会分析到
} catch (RuntimeException ex) {
Log.e(TAG, "Zygote died with exception", ex);
closeServerSocket();
throw ex;
}
}
建立IPC通信服务端– registerZygoteSocket
private static void registerZygoteSocket() {
if (sServerSocket == null) {
int fileDesc;
try {
/*
private static final String ANDROID_SOCKET_ENV =
"ANDROID_SOCKET_zygote";
*/
String env = System.getenv(ANDROID_SOCKET_ENV);
fileDesc = Integer.parseInt(env);
} catch (RuntimeException ex) {
throw new RuntimeException(
ANDROID_SOCKET_ENV + " unset or invalid", ex);
}
try {
sServerSocket = new LocalServerSocket(
createFileDescriptor(fileDesc));
} catch (IOException ex) {
throw new RuntimeException(
"Error binding to local socket '" + fileDesc + "'", ex);
}
}
从环境变量中获得名为“ANDROID_SOCKET_zygote”的值作为socket的fd，那么这个ANDROID_SOCKET_zygote环境变量又是什么时候设置的呢？
还记得在init进程初始化的时候会去解析init.rc的service服务，并且最后会调用service_start去启动服务。那么service_start函数其中有如下一段代码，用来创建通信用的socket fd：
for (si = svc->sockets; si; si = si->next) {
int socket_type = (
!strcmp(si->type, "stream") ? SOCK_STREAM :
(!strcmp(si->type, "dgram") ? SOCK_DGRAM : SOCK_SEQPACKET));
/*
create_socket其实就是往ANDROID_SOCKET_DIR中创建了一个文件，zygote进程为
/dev/socket/zygote，并返回文件fd
*/
int s = create_socket(si->name, socket_type,
si->perm, si->uid, si->gid);
if (s >= 0) {
// zygote服务的si->name即socket名也为zygote
publish_socket(si->name, s);
}
}
其中publish_socket函数就是设置ANDROID_SOCKET_zygote环境变量的地方：
static void publish_socket(const char *name, int fd)
{
/*
#define ANDROID_SOCKET_ENV_PREFIX "ANDROID_SOCKET_"
#define ANDROID_SOCKET_DIR "/dev/socket"
*/
char key[64] = ANDROID_SOCKET_ENV_PREFIX;
char val[64];
// 拼接socket的名字，即ANDROID_SOCKET_zygote
strlcpy(key + sizeof(ANDROID_SOCKET_ENV_PREFIX) - 1,
name,
sizeof(key) - sizeof(ANDROID_SOCKET_ENV_PREFIX));
snprintf(val, sizeof(val), "%d", fd);
// 添加socket的fd值到环境变量
add_environment(key, val);
/* make sure we don't close-on-exec */
fcntl(fd, F_SETFD, 0);
}
知道了ANDROID_SOCKET_ENV的来龙去脉，那么我们接着回过头来看registerZygoteSocket函数，这个函数其实很简单，就是创建了一个服务端的socket，并赋值给全局变量sServerSocket。那么这个服务端的socket具体要接受什么消息，之后又需要处理什么事件呢？我们后面再来看。
预加载类、资源等
static void preload() {
preloadClasses();
preloadResources();
preloadOpenGL();
}
先来看看类加载：
private static void preloadClasses() {
final VMRuntime runtime = VMRuntime.getRuntime();
// private static final String PRELOADED_CLASSES = "preloaded-classes";
// 预加载类的信息存储在PRELOADED_CLASSES文件中
InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream(
PRELOADED_CLASSES);
if (is == null) {
Log.e(TAG, "Couldn't find " + PRELOADED_CLASSES + ".");
} else {
……
try {
BufferedReader br
= new BufferedReader(new InputStreamReader(is), 256);
int count = 0;
String line;
while ((line = br.readLine()) != null) {
// Skip comments and blank lines.
line = line.trim();
if (line.startsWith("#") || line.equals("")) {
continue;
}
try {
……
// 通过Java反射来加载类，line为类名
Class.forName(line);
……
count++;
} catch (ClassNotFoundException e) {
Log.w(TAG, "Class not found for preloading: " + line);
} catch (Throwable t) {
……
}
}
} catch (IOException e) {
Log.e(TAG, "Error reading " + PRELOADED_CLASSES + ".", e);
} finally {
……
}
}
}
函数比较简单，就是读取preloaded-classes文件的内容，以行为单位。preloaded-classes文件的内容如下：
# Classes which are preloaded by com.android.internal.os.ZygoteInit. # Automatically generated by frameworks/base/tools/preload/WritePreloadedClassFile.java. # MIN_LOAD_TIME_MICROS=1250 # MIN_PROCESSES=10 android.R$styleable android.accounts.Account android.accounts.Account$1 android.accounts.AccountManager android.accounts.AccountManager$12 android.accounts.AccountManager$13 android.accounts.AccountManager$6 android.accounts.AccountManager$AmsTask android.accounts.AccountManager$AmsTask$1 android.accounts.AccountManager$AmsTask$Response android.accounts.AccountManagerFuture android.accounts.IaccountManager …… // 省略N行
preloaded-classes这个文件主要由frameworks\base\tools\preload工具自动生成的，工具会判断每个类加载的时间是否大于1250微妙，超过这个时间就会被写到preloaded-classes文件中，最后由zygote来预加载。它总共有1000多行的类，可见Zygote进程初始化的时候任务还是很繁重的，这也是导致Android系统启动慢的原因之一。
preloadResources和preloadOpenGL我也就不多做解释了，大体处理都差不多。
启动system_server
/**
* Prepare the arguments and fork for the system server process.
*/
private static boolean startSystemServer()
throws MethodAndArgsCaller, RuntimeException {
long capabilities = posixCapabilitiesAsBits(
OsConstants.CAP_KILL,
OsConstants.CAP_NET_ADMIN,
OsConstants.CAP_NET_BIND_SERVICE,
OsConstants.CAP_NET_BROADCAST,
OsConstants.CAP_NET_RAW,
OsConstants.CAP_SYS_MODULE,
OsConstants.CAP_SYS_NICE,
OsConstants.CAP_SYS_RESOURCE,
OsConstants.CAP_SYS_TIME,
OsConstants.CAP_SYS_TTY_CONFIG
);
/* Hardcoded command line to start the system server */
String args[] = {
"--setuid=1000", // #define AID_SYSTEM 1000
"--setgid=1000", // 1000 是系统属性
"--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1032,3001,3002,3003,3006,3007",
"--capabilities=" + capabilities + "," + capabilities,
"--runtime-init",
"--nice-name=system_server", // 进程名为system_server
"com.android.server.SystemServer", // 类名
};
ZygoteConnection.Arguments parsedArgs = null;
int pid;
try {
parsedArgs = new ZygoteConnection.Arguments(args);
ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);
/*
进程启动参数都已经在上面硬编码了
最后调用fork启动system_server进程
*/
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 */
if (pid == 0) {
// 子进程处理消息
handleSystemServerProcess(parsedArgs);
}
return true;
}
系统初始化到这里之后，系统中已经有3个进程了，最开始的init，zygote和zygote分裂出来的system_server。system_server部门我们以后再看，接着看zygote的执行。
zygote等待请求– runSelectLoop
private static void runSelectLoop() throws MethodAndArgsCaller {
ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
FileDescriptor[] fdArray = new FileDescriptor[4];
// sServerSocket是之前在registerZygoteSocket创建的服务端socket
fds.add(sServerSocket.getFileDescriptor());
peers.add(null);
int loopCount = GC_LOOP_COUNT;
while (true) {
int index;
/*
* Call gc() before we block in select().
* It's work that has to be done anyway, and it's better
* to avoid making every child do it. It will also
* madvise() any free memory as a side-effect.
*
* Don't call it every time, because walking the entire
* heap is a lot of overhead to free a few hundred bytes.
*/
if (loopCount <= 0) {
gc();
loopCount = GC_LOOP_COUNT;
} else {
loopCount--;
}
try {
fdArray = fds.toArray(fdArray);
/*
selectReadable是一个native函数，内部调用select等待客户端
的连接，客户端连接上之后就会返回。
返回值：
<0: 内部发生错误
=0: 该客户端第一次连接到服务端
>0: 客户端与服务端已经建立连接，并开始发送数据
*/
index = selectReadable(fdArray);
} catch (IOException ex) {
throw new RuntimeException("Error in select()", ex);
}
if (index < 0) {
throw new RuntimeException("Error in select()");
} else if (index == 0) {
/*
返回0，表明该客户端第一次请求服务端，服务端调用accept与客户
端建立连接。客户端在zygote中以ZygoteConnection对象表示。
*/
ZygoteConnection newPeer = acceptCommandPeer();
peers.add(newPeer);
fds.add(newPeer.getFileDesciptor());
} else {
boolean done;
/*
返回>0，表明发送数据的客户端的index，peers.get(index)取得
发送数据客户端的ZygoteConnection对象，之后调用runOnce
函数处理具体的请求。
*/
done = peers.get(index).runOnce();
// 请求处理完成之后，移除与该客户端的连接
if (done) {
peers.remove(index);
fds.remove(index);
}
}
}
}
runSelectLoop函数的逻辑比较简单，主要有两点
1、 处理客户端的连接和请求。其中客户端在zygote进程中使用ZygoteConnection对象表示。
2、 客户的请求有ZygoteConnection的runOnce来处理。
Zygote总结
Zygote是在android系统中创建java世界的盘古，它创建了第一个java虚拟机。同时，它又是女娲，它成功的繁殖了framework的核心system_server进程。主要步骤如下：
1、 创建AppRuntime对象，并调用其start函数。之后zygote的核心初始化都由AppRuntime中。
2、 调用startVm创建java虚拟机，然后调用startReg来注册JNI函数。
3、 通过JNI调用com.android.internal.os.ZygoteInit类的main函数，从此进入了java世界。
4、 调用registerZygoteSocket创建可以响应子孙后代请求的socket。同时，zygote调用preload函数预加载了常用的类、资源等，为java世界添砖加瓦。
5、 调用startSystemServer函数分裂了一个子进程system_server来为java世界服务。
6、 Zygote完成了java世界的初创工作，便调用runSelectLoop来让自己沉沉的睡去。之后，如果收到子孙后代的请求，它便会醒来为他们工作。