Android的应用程序一般都是由Java语言编写而成的，这样的应用程序需要运行在独自的Dalvik虚拟机之上（当然，5.0好像默认了ART了）。但是，如果在每一个进程启动时都在物理内存中创建和初始化一个Dalvik虚拟机，这无疑对系统的性能造成很大的影响。Zygote是Android系统中的一个非常重要的守护进程，所有其他应用程序的Dalvik虚拟机都是通过Zygote孵化出来的。通过这种方式，虚拟机的内存和框架层的资源被所有应用程序共享，从而提高了应用程序的启动和运行速度。下图为Android启动的大致流程。
图1. Android系统启动的大致流程
抛开硬件层的有关内容后，Android的源头应该为init进程。这个linux进程在操作系统的内核启动的后期就被启动了，并且之后所有的进程都是它的子孙进程。Init进程由main()开始，截取的部分代码如下：
int main(int argc, char **argv)
{
……
//创建并挂载了一些基本的系统文件
mkdir("/dev", 0755);
mkdir("/proc", 0755);
mkdir("/sys", 0755);
mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
mkdir("/dev/pts", 0755);
mkdir("/dev/socket", 0755);
mount("devpts", "/dev/pts", "devpts", 0, NULL);
mount("proc", "/proc", "proc", 0, NULL);
mount("sysfs", "/sys", "sysfs", 0, NULL);
……
//初始化了部分属性
property_init();
……
property_load_boot_defaults();
//加载了启动配置文件，即init.rc文件
init_parse_config_file("/init.rc");
//触发Action
action_for_each_trigger("early-init", action_add_queue_tail);
queue_builtin_action(wait_for_coldboot_done_action, "wait_for_coldboot_done");
queue_builtin_action(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng");
queue_builtin_action(keychord_init_action, "keychord_init");
queue_builtin_action(console_init_action, "console_init");
……
queue_builtin_action(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng");
queue_builtin_action(property_service_init_action, "property_service_init");
queue_builtin_action(signal_init_action, "signal_init");
……
for(;;) {
int nr, i, timeout = -1;
execute_one_command();//执行当前Command中的一个命令，Action和Service被启动
restart_processes(); //重新启动设置了重新启动标志位的进程
//监听来自属性服务的事件
if (!property_set_fd_init && get_property_set_fd() > 0) {
ufds[fd_count].fd = get_property_set_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
property_set_fd_init = 1;
}
//监控singal，如果子进程异常退出，内核将抛出SIGCHILD信号，此时将可以对进程进行处理
//或是回收系统资源,或是重启子进程
if (!signal_fd_init && get_signal_fd() > 0) {
ufds[fd_count].fd = get_signal_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
signal_fd_init = 1;
}
//监听来自keychord设备的事件，这是个组合按键设备
if (!keychord_fd_init && get_keychord_fd() > 0) {
ufds[fd_count].fd = get_keychord_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
keychord_fd_init = 1;
}
……
nr = poll(ufds, fd_count, timeout);//利用poll监听以上事件
if (nr <= 0)
continue;
for (i = 0; i < fd_count; i++) {
if (ufds[i].revents & POLLIN) {
if (ufds[i].fd == get_property_set_fd())
handle_property_set_fd();//处理属性服务相关事件
else if (ufds[i].fd == get_keychord_fd())
handle_keychord();//处理keychord事件
else if (ufds[i].fd == get_signal_fd())
handle_signal();//处理singal事件
}
}
}
return 0;
Zygote作为一个服务也被定义在了init.rc文件中，由init进程派生出来，配置代码截取在如下：
service zygote /system/bin/app_process -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 media
onrestart restart netd
由于Zygote是由java的服务进程，其启动过程和其他在init.rc文件中定义的service启动不太一样。
通过配置信息可以定位Zygote的入口函数为app_main.cpp中的main，其代码截取如下：
int main(int argc, char* const argv[])
{
……
//此类是AndroidRuntime的派生类
AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
……
while (i < argc) {//遍历Zygote的配置参数
const char* arg = argv[i++];
if (strcmp(arg, "--zygote") == 0) {//为进程更换名字
zygote = true;
niceName = ZYGOTE_NICE_NAME;
} else if (strcmp(arg, "--start-system-server") == 0) {//设置systemServer为true
startSystemServer = true;
} else if (strcmp(arg, "--application") == 0) {//设置application启动为true
application = true;
} else if (strncmp(arg, "--nice-name=", 12) == 0) {
……
}
}
……
if (zygote) {//如果配置参数中有参数显示需要启动Zygote,则ZygoteInit启动
runtime.start("com.android.internal.os.ZygoteInit", args);
} else if (className) {//否则RuntimeInit启动
runtime.start("com.android.internal.os.RuntimeInit", args);
} else {
……
}
}
可见，app_main.cpp中的main()最为主要的是创建了一个AppRuntime变量，接着调用了它的start()成员函数。AppRuntime类继承自AndroidRuntime类，它并没有实现自己的start()方法，因此调用的是AndroidRuntime ：：start()。而根据之前对App_main.cpp中main函数的分析，传入到AndroidRuntime.start()的参数存在两种情况：
1）runtime.start("com.android.internal.os.ZygoteInit",args)
2）runtime.start("com.android.internal.os.RuntimeInit",args)
因此可能存在两种不同的启动方式， “RuntimeInit”式启动时序大致如下图所示：
图2. “RuntimeInit”式启动时序
由于在init.rc文件的Zygote服务已经配置了相关参数，因此这里只对ZygoteInit进行分析。AndroidRuntime.start()的主要作用是启动Android系统运行时库，代码截取如下：
void AndroidRuntime::start(const char* className, const Vector<String8>& options)
{
……//配置虚拟机的一些参数
JniInvocation jni_invocation;
jni_invocation.Init(NULL);
JNIEnv* env;
//开启虚拟机
if (startVm(&mJavaVM, &env) != 0) {
return;
}
//这里实际上是调用了子类AppRuntime的onVmCreate(env)
onVmCreated(env);
//注册Android JNI函数
if (startReg(env) < 0) {
ALOGE("Unable to register all android natives\n");
return;
}
//在开始调用main之前需要将参数转化成java可识别的类型，并将其全部存入一个数组
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);
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);
}
char* slashClassName = toSlashClassName(className);
//找到需要启动的java类
jclass startClass = env->FindClass(slashClassName);
if (startClass == NULL) {
ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
} else {
//得到指定类中指定方法的ID，这里得到的是ZygoteInit.main()的方法ID
jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
"([Ljava/lang/String;)V");
if (startMeth == NULL) {
ALOGE("JavaVM unable to find main() in '%s'\n", className);
} else {
//调用上面得到的方法ID和相关参数，即调用Java类ZygoteInit.main();
env->CallStaticVoidMethod(startClass, startMeth, strArray);
……
}
}
……//回收资源关闭虚拟机等操作，这个函数除非进程退出，否则不会返回
}
AndroidRuntime.start()实际上主要做了3件事：1，startVM开启虚拟机；2，startReg()注册了JNI方法；3，调用Java方法。
ZygoteInit相关的类图结构大致如下：
图3. ZygoteInit相关类图结构
根据init.rc中Zygote的配置参数，AndroidRuntime.start()最终调用的是ZgoteInit.main()。其代码截取如下：
public static void main(String argv[]) {
try {
……
registerZygoteSocket(socketName);//初始化了server(zygote)的一个localsocket
EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,
SystemClock.uptimeMillis());
preload();//加载了framwork.jar的class和资源到内存，这部分很占CPU
EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,
SystemClock.uptimeMillis());
SamplingProfilerIntegration.writeZygoteSnapshot();
gc();//由于后续需要fork出应用程序的进程,需要进行垃圾回收以确保应用程序的性能
Trace.setTracingEnabled(false);
if (startSystemServer) {
startSystemServer(abiList, socketName);//开启System server服务
}
Log.i(TAG, "Accepting command socket connections");
runSelectLoop(abiList);//开启循环
closeServerSocket();
} catch (MethodAndArgsCaller caller) {
caller.run();//这里实际上是真正开启了systemServer进程
} catch (RuntimeException ex) {
Log.e(TAG, "Zygote died with exception", ex);
closeServerSocket();
throw ex;
}
}
在ZygoteInit.main()中首先是调用了registerZygoteSocket(..)方法，该方法主要是为Zygote服务创建了一个localSocket。接着调用preload将class资源和系统的Resource加载到了内存中。之后利用gc()对垃圾进行回收。由于linux的写时复制机制，在fork出应用程序之前对垃圾进行回收可以最小化子进程的垃圾内存。之后，ZygoteInit.main()分别调用了startSystemServer()、runSelectLoop()方法。startSystemServer()开启了SystemServer，此进程是Zygote孵化出来的第一个java进程。而runSelectLoop()进入select的循环，用来响应其他应用程序（AMS）的请求。
SystemServer进程是Zygote 孵化出来的第一个进程，此进程有很多的系统进程，提供了所有核心的系统服务。与孵化其他进程不同，Zygote单独对SystemServer进程做了孵化工作。ZygoteInit.main()中调用了startSystemServer()，代码如下：
private static boolean startSystemServer(String abiList, String socketName)
throws MethodAndArgsCaller, RuntimeException {
long capabilities = posixCapabilitiesAsBits(
OsConstants.CAP_BLOCK_SUSPEND,
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
);
//SystemServer的启动参数设置
String args[] = {
"--setuid=1000",
"--setgid=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",
"com.android.server.SystemServer",
};
ZygoteConnection.Arguments parsedArgs = null;
int pid;
try {
parsedArgs = new ZygoteConnection.Arguments(args);
ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);
//向Zygote发送fork请求
pid = Zygote.forkSystemServer(
parsedArgs.uid, parsedArgs.gid,
parsedArgs.gids,
parsedArgs.debugFlags,
null,
parsedArgs.permittedCapabilities,
parsedArgs.effectiveCapabilities);
} catch (IllegalArgumentException ex) {
throw new RuntimeException(ex);
}
//以下代码仅对子进程SystemServer有效
if (pid == 0) {
if (hasSecondZygote(abiList)) {
waitForSecondaryZygote(socketName);
}
handleSystemServerProcess(parsedArgs);
}
return true;
}
进入handleSystemServerProcess(parsedArgs)，从代码中可以看到Zygote根据请求创建了SystemServer进程，这个进程运行handleSystemServerProcess()。此函数对部分参数做了处理，并将剩余的参数传递给了SystemServer。
private static void handleSystemServerProcess(
ZygoteConnection.Arguments parsedArgs)
throws ZygoteInit.MethodAndArgsCaller {
closeServerSocket();
//设置默认权限
Os.umask(S_IRWXG | S_IRWXO);
if (parsedArgs.niceName != null) {
Process.setArgV0(parsedArgs.niceName);
}
final String systemServerClasspath = Os.getenv("SYSTEMSERVERCLASSPATH");
if (systemServerClasspath != null) {
performSystemServerDexOpt(systemServerClasspath);
}
if (parsedArgs.invokeWith != null) {
String[] args = parsedArgs.remainingArgs;
if (systemServerClasspath != null) {
String[] amendedArgs = new String[args.length + 2];
amendedArgs[0] = "-cp";
amendedArgs[1] = systemServerClasspath;
System.arraycopy(parsedArgs.remainingArgs, 0, amendedArgs, 2, parsedArgs.remainingArgs.length);
}
//一种可能的启动方式
WrapperInit.execApplication(parsedArgs.invokeWith,
parsedArgs.niceName, parsedArgs.targetSdkVersion,
null, args);
} else {//更为常见的启动方式
ClassLoader cl = null;
if (systemServerClasspath != null) {
cl = new PathClassLoader(systemServerClasspath, ClassLoader.getSystemClassLoader());
Thread.currentThread().setContextClassLoader(cl);
}
//将余下的参数传递给RuntimeInit.zygoteInit处理
RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
}
//永远不会执行到这里
}
进入RuntimeInit.zygoteInit()
public static final void zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
throws ZygoteInit.MethodAndArgsCaller {
if (DEBUG) Slog.d(TAG, "RuntimeInit: Starting application from zygote");
//重定向log
redirectLogStreams();
//初始化运行环境
commonInit();
//启动binder线程池
nativeZygoteInit();
//调用应用程序的入口函数
applicationInit(targetSdkVersion, argv, classLoader);
}
进入applicationInit()
private static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) throws ZygoteInit.MethodAndArgsCaller{
nativeSetExitWithoutCleanup(true);
……
invokeStaticMain(args.startClass, args.startArgs, classLoader);
}
进入invokeStaticMain ()
private static void invokeStaticMain(String className, String[] argv, ClassLoader classLoader)
throws ZygoteInit.MethodAndArgsCaller {
//解析类名
Class<?> cl;
try {
cl = Class.forName(className, true, classLoader);
} catch (ClassNotFoundException ex) {
throw new RuntimeException(
"Missing class when invoking static main " + className,
ex);
}
//解析main方法
Method m;
try {
m = cl.getMethod("main", new Class[] { String[].class });
} catch (NoSuchMethodException ex) {
throw new RuntimeException(
"Missing static main on " + className, ex);
} catch (SecurityException ex) {
throw new RuntimeException(
"Problem getting static main on " + className, ex);
}
int modifiers = m.getModifiers();
if (! (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))) {
throw new RuntimeException(
"Main method is not public and static on " + className);
}
//这里并没有直接去调用SystemServer.main()而是抛出了一个异常，这个异常将在//ZygoteInit.main()中被捕捉
throw new ZygoteInit.MethodAndArgsCaller(m, argv);
}
这里非常奇怪，invokeStaticMain并没有像我们想象的那样直接去调用SystemServer类的有关代码，它只是获取了SystemServer.main方法体和有关参数，并将其封装在一个MethodAndArgsCaller异常中，这个异常将在ZygoteInit.main中被捕捉。具体可以查看之前的代码。先查看一下这个异常类的设计，进入MethodAndArgsCaller类查看代码。
public static class MethodAndArgsCaller extends Exception
implements Runnable {
//调用方法体
private final Method mMethod;
//调用方法所需要的参数
private final String[] mArgs;
public MethodAndArgsCaller(Method method, String[] args) {
mMethod = method;
mArgs = args;
}
public void run() {
try {
//最终还是调用了main()方法
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异常分析：MethodAndArgsCaller异常是在startSystemSerer()中抛出的，从单个文件的代码来看，程序的执行流跳过runSelectLoop(..)。而runSelectLoop()是Zygote的服务的一个非常重要的方法。这显然不合理。考虑到startSystemServer中开启了名字为SystemServer的进程（此时，这个子进程程序流还未流入SystemServer.main()），抛出这个异常MethodAndArgsCaller的实际上是handleSystemServerProcess()的，即SystemServer进程，而父进程Zygote并未受影响。因此跳过runSelectLoop(..)是合理的。通过这样的方式，可以摆脱在启动初期时设置的堆栈桢。这些应该都和linux的fork机制有关。
以上SystemServer的启动流程大致时序如下图所示。
图4. SystemServer启动大致时序
在分析runSelectLoop之前，需要对应用程序的启动流程作一下简要的分析。应用程序的主入口是在ActivityThread的main函数，activity的startActivity最终是在ActivityManagerService中执行的。
首先调用的是ActivityManagerService.startProcessLocked()方法，这个方法有多个重载方法，但是都会调用Process.startViaZygote()，这个方法内部实际上是开启一个localSocket并连接Zygote进程（此时的Zygote正处于runSelectLoop之中监听事件）。建立连接之后首先是将参数通过localsocket对应的writer对象发送了所要启动APP的相关参数给Zygote，并等待localsocke对应的inputStream返回一个int型的pid。以及另一个boolean型的参数usingWrapper。
图5. 启动应用程序大致时序
之前已经描述，Zygote在建立ServerSystem服务之后一直处于runSelectLoop循环中，等待AMS的fork请求，runSelectLoop代码截取如下：
private static void runSelectLoop(String abiList) throws MethodAndArgsCaller {
ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
FileDescriptor[] fdArray = new FileDescriptor[4];
fds.add(sServerSocket.getFileDescriptor());
peers.add(null);
int loopCount = GC_LOOP_COUNT;
while (true) {
int index;
if (loopCount <= 0) {
gc();//在比较空闲的时候执行gc
loopCount = GC_LOOP_COUNT;
} else {
loopCount--;
}
try {
fdArray = fds.toArray(fdArray);
//这是一个Native方法，其方法内部调用了Select系统函数等待客户端连接请求
index = selectReadable(fdArray);//注意这里的返回值和select()的返回值是不//同的概念,这里Index是活动fd的索引
} catch (IOException ex) {
throw new RuntimeException("Error in select()", ex);
}
if (index < 0) {
throw new RuntimeException("Error in select()");
} else if (index == 0) {//有连接进入，放入监听fd队列
ZygoteConnection newPeer = acceptCommandPeer(abiList);
peers.add(newPeer);
fds.add(newPeer.getFileDescriptor());
} else {//有请求
boolean done;
done = peers.get(index).runOnce();//处理请求
if (done) {
peers.remove(index);
fds.remove(index);
}
}
}
}
进入runOnce()
boolean runOnce() throws ZygoteInit.MethodAndArgsCaller {
String args[];
Arguments parsedArgs = null;
FileDescriptor[] descriptors;
long startTime = SystemClock.elapsedRealtime();
try {
args = readArgumentList();//读取传递进来的请求参数
descriptors = mSocket.getAncillaryFileDescriptors();
}……
……//fork出应用进程
pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,
parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,
parsedArgs.niceName, fdsToClose, parsedArgs.instructionSet,
parsedArgs.appDataDir);
……
try {
if (pid == 0) {
// 子进程中
IoUtils.closeQuietly(serverPipeFd);
serverPipeFd = null;
handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);
return true;
} else {
// 父进程中
IoUtils.closeQuietly(childPipeFd);
childPipeFd = null;
//发送pid和usingWrapper给AMS
return handleParentProc(pid, descriptors, serverPipeFd, parsedArgs);
}
} finally {
IoUtils.closeQuietly(childPipeFd);
IoUtils.closeQuietly(serverPipeFd);
}
}
进入handleChildProc()
private void handleChildProc(Arguments parsedArgs,
FileDescriptor[] descriptors, FileDescriptor pipeFd, PrintStream newStderr)
throws ZygoteInit.MethodAndArgsCaller {
closeSocket();
ZygoteInit.closeServerSocket();
……
if (parsedArgs.niceName != null) {//设置进程名字
Process.setArgV0(parsedArgs.niceName);
}
//参数中配置了RuntimeInit,这里为true
if (parsedArgs.runtimeInit) {
if (parsedArgs.invokeWith != null) {//Android中另一种可能的启动方式
WrapperInit.execApplication(parsedArgs.invokeWith,
parsedArgs.niceName, parsedArgs.targetSdkVersion,
pipeFd, parsedArgs.remainingArgs);
} else {//程序最终会走到这里
RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion,
parsedArgs.remainingArgs, null);
}
} else {
……
}
}
可看到，handleChildProc最终调用RuntimeInit.ZygoteInit()。这个方法在分析SystemServer启动过程时已经分析过了，它依次调用了redirectLogStreams()、commonInit()、zygoteInitNative() applicationInit()并最终调用了invokeStaticMain()抛出异常，在catch块中运行指定类的main函数。
本文主要分析了Android5.0中Zygote的启动，以及Zygote孵化SystemServer进程和普通应用进程的过程。从以上的分析可以得知，Android充分利用了Linux的一些特性，在保证了内存被尽可能地共享的同时，又保证了系统的性能和速度
原文地址： http://blog.csdn.net/a34140974/article/details/49783781
