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 启动该服务执行的命令： /system/bin/app_process
命令的参数： -Xzygote /system/bin --zygote --start-system-server
socket zygote stream 660： 创建一个名为：/dev/socket/zygote 的 socket ，类型为：stream
app_main.cpp
Zygote的main函数在\frameworks\base\cmds\app_process\app_main.cpp，如下：int main(int argc, const char* const argv[])
{
...
int i = runtime.addVmArguments(argc, argv);
//返回的i一般会是1
while (i < argc) {
const char* arg = argv[i++];
if (!parentDir) {
//取值应该是/system/bin
parentDir = arg;
} else if (strcmp(arg, "--zygote") == 0) {
zygote = true;
niceName = "zygote";
} 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 = arg + 12;
} else {
className = arg;
break;
}
}
if (niceName && *niceName) {
setArgv0(argv0, niceName);
//把app_process的进程名改为zygote
set_process_name(niceName);
}
runtime.mParentDir = parentDir;
if (zygote) {
//核心代码
runtime.start("com.android.internal.os.ZygoteInit",startSystemServer ? "start-system-server" : "");
} else if (className) {
// Remainder of args get passed to startup class main()
runtime.mClassName = className;
runtime.mArgC = argc - i;
runtime.mArgV = argv + i;
runtime.start("com.android.internal.os.RuntimeInit",
application ? "application" : "tool");
} else {
fprintf(stderr, "Error: no class name or --zygote supplied.\n");
app_usage();
LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
return 10;
}
}如果运行正常的话，会走到runtime.start("com.android.internal.os.ZygoteInit",startSystemServer ? "start-system-server" : "")，如下：void AndroidRuntime::start(const char* className, const char* options)
{
ALOGD("\n>>>>>> AndroidRuntime START %s <<<<<<\n",
className != NULL ? className : "(unknown)");
//创建一个信号管道
blockSigpipe();
...
//启动虚拟机
JNIEnv* env;
if (startVm(&mJavaVM, &env) != 0) {
return;
}
//空函数
onVmCreated(env);
//注册android的native函数(JNI的接口),注册了一个用于创建线程的函数（javaCreateThreadEtc）
if (startReg(env) < 0) {
ALOGE("Unable to register all android natives\n");
return;
}
//创建java.lang.String数组，其内容值是：[ “com.android.internal.os.ZygoteInit”,“true”]
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.
*/
char* slashClassName = toSlashClassName(className);
//查找com.android.internal.os.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");
if (startMeth == NULL) {
ALOGE("JavaVM unable to find main() in ‘%s‘\n", className);
/* keep going */
} else {
//调用ZygoteInit类的main函数，参数是strArray。虚拟机执行的第一个Java类就是ZygoteInit.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");
}
ZygoteInit.java
虚拟机执行的第一个Java类就是ZygoteInit.java，它的main函数如下：public static void main(String argv[]) {
try {
// Start profiling the zygote initialization.
SamplingProfilerIntegration.start();
//创建了一个socket接口，用来和ActivityManagerService通讯
registerZygoteSocket();
//装载Framework大部分类及资源，并和子进程共享
EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,SystemClock.uptimeMillis());
preload();
EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END, SystemClock.uptimeMillis());
// Finish profiling the zygote initialization.
SamplingProfilerIntegration.writeZygoteSnapshot();
// Do an initial gc to clean up after startup
gc();
// If requested, start system server directly from Zygote
if (argv.length != 2) {
throw new RuntimeException(argv[0] + USAGE_STRING);
}
//启动SystemServer,此处会启动一个新的进程
if (argv[1].equals("start-system-server")) {
startSystemServer();
} else if (!argv[1].equals("")) {
throw new RuntimeException(argv[0] + USAGE_STRING);
}
Log.i(TAG, "Accepting command socket connections");
if (ZYGOTE_FORK_MODE) {
runForkMode();
} else {
//无限循环，在前面创建的socket接口上等待ActivityManagerService请求创建新的应用程序进程
runSelectLoopMode();
}
closeServerSocket();
} catch (MethodAndArgsCaller caller) {
caller.run();
} catch (RuntimeException ex) {
Log.e(TAG, "Zygote died with exception", ex);
closeServerSocket();
throw ex;
}
}
创建socket接口
private static void registerZygoteSocket() {
if (sServerSocket == null) {
int fileDesc;
try {
//获取socket描述符
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 {
//在Linux系统中，所有的系统资源都可以看成是文件，甚至包括内存和CPU，因此，像标准的磁盘文件或者网络Socket自然也被认为是文件，这就是为什么LocalServerSocket构造函数的参数是一个文件描述符。
sServerSocket = new LocalServerSocket(
createFileDescriptor(fileDesc));
} catch (IOException ex) {
throw new RuntimeException(
"Error binding to local socket ‘" + fileDesc + "‘", ex);
}
}
}
Socket编程中有两种方式去触发Socket数据读操作。一种是使用listen()监听某个端口，然后调用read()去从这个端口上读数据，这种方式被称为阻塞式读操作，因为当端口没有数据时，read()函数将一直等待，直到数据准备好后才返回；另一种是使用select()函数将需要监测的文件描述符作为select()函数的参数，然后当该文件描述符上出现新的数据后，自动触发一个中断，然后在中断处理函数中再去读指定文件描述符上的数据，这种方式被称为非阻塞式读操作。LocalServerSocket中使用的正是后者，即非阻塞读操作。
预加载类和资源
在Android源码编译的时候，会最终把preload-classes文件打包到framework.jar中。ZygoteInit中通过调用preloadClasses()完成装载这些类。装载的方法很简单，就是读取preload-classes列表中的每一行，因为每一行代表了一个具体的类，然后调用Class.forName()装载目标类。preloadResources()函数中分别调用preloadDrawables()和preloadColorStateLists()加载两类资源。加载的原理很简单，就是把这些资源读出来放到一个全局变量中，只要该类对象不被销毁，这些全局变量就会一直保存。保存Drawable资源的全局变量是mResources，该变量的类型是Resources类，由于该类内部会保存一个Drawable资源列表，因此，实际上缓存这些Drawable资源是在Resources内部；保存Color资源的全局变量也是mResources，同样，Resources类内部也有一个Color资源的列表。
static void preload() {
preloadClasses();
preloadResources();
}
循环等待服务
private static void runSelectLoopMode() throws MethodAndArgsCaller {
//首先将sServerSocket加入到被监测的文件描述符列表中
ArrayList<FileDescriptor> fds = new ArrayList();
ArrayList<ZygoteConnection> peers = new ArrayList();
FileDescriptor[] fdArray = new FileDescriptor[4];
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--;
}
//selectReadable()函数的返回值有三种。一种是-1，代表着内部错误；第二种是0，代表着没有可处理的连接，因此会以Socket服务端口重新建立一个ZygoteConnection对象，并等待客户端的请求；第三种是大于0， 代表着还有没处理完的连接请求，因此需要先处理该请求，而暂时不需要建立新的连接等待。
try {
fdArray = fds.toArray(fdArray);
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) {
//接受Android应用的socket命令
ZygoteConnection newPeer = acceptCommandPeer();
peers.add(newPeer);
fds.add(newPeer.getFileDesciptor());
} else {
boolean done;
//基于zygote进程孵化出新的应用进程
done = peers.get(index).runOnce();
if (done) {
peers.remove(index);
fds.remove(index);
}
}
}
}
fork创建进程
fork是Linux系统的一个系统调用，其作用是复制当前进程，产生一个新的进程。新进程将拥有和原始进程完全相同的进程信息，除了进程id不同。进程信息包括该进程所打开的文件描述符列表、所分配的内存等。当新进程被创建后，两个进程将共享已经分配的内存空间，直到其中一个需要向内存中写入数据时，操作系统才负责复制一份目标地址空间，并将要写的数据写入到新的地址中，这就是所谓的copy-on-write机制，即“仅当写的时候才复制”，这种机制可以最大限度地在多个进程*享物理内存。这就是我们会先预加载framework的类和资源的原因，这样子进程就可以与zygote共享framework资源了。在操作系统内部，启动新的进程包含三个过程。
第一个过程，内核创建一个进程数据结构，用于表示将要启动的进程。
第二个过程，内核调用程序装载器函数，从指定的程序文件读取程序代码，并将这些程序代码装载到预先设定的内存地址。
第三个过程，装载完毕后，内核将程序指针指向到目标程序地址的入口处开始执行指定的进程。当然，实际的过程会考虑更多的细节，不过大致思路就是这么简单。
由于fork()函数是Linux的系统调用，Android中的Java层仅仅是对该调用进行了JNI封装而已。ZygoteConnection类的runOnce()函数就是通过JNI调用fork()函数创建子进程的。
fork调用的一个奇妙之处就是它仅仅被调用一次，却能够返回两次，它可能有三种不同的返回值：
1）在父进程中，fork返回新创建子进程的进程ID；
2）在子进程中，fork返回0；
3）如果出现错误，fork返回一个负值；
zygote已经创建了一个Socket服务端，而这个服务端是不应该被新进程使用的，否则系统中会有多个进程接收Socket客户端的命令。因此，新进程被创建好后，首先需要在新进程中关闭该Socket服务端，并调用新进程中指定的Class文件的main()函数作为新进程的入口点。而这些正是在调用forkAndSpecialize()函数后根据返回值pid完成的。