简介：
Android中，Zygote是整个Android系统的核心进程，是Android系统的心脏。所有的Android应用程序，包括Android框架层所在的进程system_server，都是由Zygote孵化（通过Linux系统调用fork函数创建）出来的。
Zygote初探：
我们说，zygote是整个Android系统的心脏，在zygote被启动的同时，还启动了其它的很多守护进程，有的比zygote启动的还早。 换句话说，在zygote还没有启动时，其实，作为底层的Linux系统已经启动了，标志就是init进程已经启动。
如果我们在adb shell命令行，用kill命令（在root的情况下），居然可以杀死zygote，然后，设备屏幕又会显示“>>>>>>>>>>>>>> AndroidRuntime START <<<<<<<<<<<<<<”，即android系统重启。
zytote是一个实实在在的进程，可以在进程列表中查看到：
USER PID PPID VSIZE RSS WCHAN PC NAME
root 1 0 548 196 c00b8c14 0000d5cc S /init
root 2 0 0 0 c006bf70 00000000 S kthreadd
……
root 724 2 0 0 c0216908 00000000 S mmcqd
root 726 1 772 180 c019dbc4 afe0c1dc S /system/bin/sh
system 727 1 840 188 c022d8a0 afe0c47c S /system/bin/servicemanager
……
root 734 1 72000 14172 c00b92b0 afe0c5a4 S zygote
……system 825 734 574128 28360 ffffffff afe0c47c S system_server
……app_22 890 734 117068 30228 ffffffff afe0d404 S oms.home
可以看到，
zygote的父进程id是1，即init进程，而且，zygote的权限是root权限；
system_server是Android系统框架所在的进程，即AMS，WMS等很多服务所在的就是这个进程。system_server的父进程就是zygote；
oms.home:是home应用，即手机桌面应用。oms是Ophone系统（中国移动基于Android系统进行定制的一个系统）。作为应用程序，它的父进程也是zygote。
下图，是比较重要的一些进程的相关关系：
zygote的启动流程简单说明：
1）创建Java虚拟机；
2）为Java虚拟机注册native方法；
3）在com.android.internal.os.ZygoteInit中调用java类的主要方法；
4）加载ZygoteInit class；
5）注册zygote socket；
6）加载preload class；
7）加载preload 资源文件；
8）调用Zygote::forkSystemServer，fork一个新的进程，调用SystemServer的main方法，从而进入到java层的system_server进程的初始化流程中；
zygote进程初始化源代码分析：
代码位置：“frameworks/base/core/java/com/android/internal/os/
zygote进程是由init.rc文件中启动的，如下：
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 netdapp_process：
其中app_process被编译成一个可执行程序，
代码位置：frameworks\base\cmds\app_process，分析如下：
1）Android.mk:
Android.mk:
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
LOCAL_SRC_FILES:= \
app_main.cpp
LOCAL_SHARED_LIBRARIES := \
libcutils \
libutils \
libandroid_runtime
LOCAL_MODULE:= app_process
include $(BUILD_EXECUTABLE)其中，app_main.cpp是入口，而且，引用了libandroid_runtime库。
2）app_main.cpp:
看一下app_main.cpp的main函数：
int main(int argc, const char* const argv[])
{
// These are global variables in ProcessState.cpp
mArgC = argc;
mArgV = argv;
mArgLen = 0;
for (int i=0; i<argc; i++) {
mArgLen += strlen(argv[i]) + 1;
}
mArgLen--;
AppRuntime runtime;
const char* argv0 = argv[0];
// Process command line arguments
// ignore argv[0]
argc--;
argv++;
// Everything up to '--' or first non '-' arg goes to the vm
int i = runtime.addVmArguments(argc, argv);
// Parse runtime arguments. Stop at first unrecognized option.
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;
} 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);
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;
}
}分析：
(1)根据输入参数来判断，该如何进行runtime.start参数的配置。在上面的initl.rc中，参数是：
-Xzygote /system/bin –zygote –start-system-server
所以 ，有：
zygote = true;
startSystemServer = true;
然后，会执行到：
runtime.start(“com.android.internal.os.ZygoteInit”,
startSystemServer ? “start-system-server” : “”);
去通过ZygoteInit来继续进行zygote的初始化流程。
3）runtime：
既然ZygoteIni由truntime.start来运行，看一下runtime的实现：
类图：
流程图：
分析：
如果是“–zygote”，则启动zygote进程相关代码；
否则，会根据参数，启动（创建）参数所在的app。
4）ZygoteInit：
在分析完runtime之后，再来看一runtime.start的第一个参数“
com.android.internal.os.ZygoteInit
”的相关实现：
代码位置：frameworks/base/core/java/com/android/internal/os/ZygoteInit.java。
这是个java代码，也就是说，执行了大半天，这时候终于执行到了java代码，有runtime（即dvm虚拟机的runtime运行时库）启动了java代码。看一下这个目录的代码文件（已经是java代码了）：
在这个目录下，没有Android.mk文件。这是因为这已经是java层了，而不是native层。对于java层的代码来说，只是说是不是要打包到jar中。而对于C/C++来说，要编译成lib,或者exe。
其中，ZygoteInit的 流程图如下：
分析：
（1）为zygote注册一个socket，并且保存起来，保存到
sServerSocket
变量中；这是一个LocalServerSocket类型的socket，详细代码如下：
private static void registerZygoteSocket() {
if (sServerSocket == null) {
int fileDesc;
try {
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);
}
}
}同时，创建了文件描述符FileDescriptor, 即ANDROID_SOCKET_ENV环境变量对应的文件描述符FileDescriptor，ANDROID_SOCKET_ENV的定义：
private static final String ANDROID_SOCKET_ENV = “ANDROID_SOCKET_zygote”;
（2）预加载一些class和资源文件。这样的好处是，会加快app的启动。当一个app启动时，就不需要重新加载这些资源了；
（3）孵化（fork）SystemServer进程：Zygote::SystemServer就会通过系统调用fork函数来创建一个新的进程，这个进程就是SystemServer；
（4）然后，执行到SystemServer的main方法，这是一个java类，整个SystemServer的文件中，定义了两个类，如下：
5) SystemServer:
在SystemServer.main方法中，
System.loadLibrary(“android_servers”); //加载“android_servers”库
init1(args); //这是个jni接口，会再调用到native层的init1方法中。
然后，init1会执行到native层，然后再通过native层调用到java层的init2方法，相关代码流程：
SystemServer.java -> com_android_server_SystemServer.cpp -> system_init.cpp ->SystemServer.java
com_android_server_SystemServer.cpp的init1函数:
static void android_server_SystemServer_init1(JNIEnv* env, jobject clazz)
{
system_init();
}
system_init的实现（在system_init.cpp文件中）：
extern "C" status_t system_init()
{
ALOGI("Entered system_init()");
sp<ProcessState> proc(ProcessState::self());
sp<IServiceManager> sm = defaultServiceManager();
ALOGI("ServiceManager: %p\n", sm.get());
sp<GrimReaper> grim = new GrimReaper();
sm->asBinder()->linkToDeath(grim, grim.get(), 0);
char propBuf[PROPERTY_VALUE_MAX];
property_get("system_init.startsurfaceflinger", propBuf, "1");
if (strcmp(propBuf, "1") == 0) {
// Start the SurfaceFlinger
SurfaceFlinger::instantiate();
}
property_get("system_init.startsensorservice", propBuf, "1");
if (strcmp(propBuf, "1") == 0) {
// Start the sensor service
SensorService::instantiate();
}
// And now start the Android runtime. We have to do this bit
// of nastiness because the Android runtime initialization requires
// some of the core system services to already be started.
// All other servers should just start the Android runtime at
// the beginning of their processes's main(), before calling
// the init function.
ALOGI("System server: starting Android runtime.\n");
AndroidRuntime* runtime = AndroidRuntime::getRuntime();
ALOGI("System server: starting Android services.\n");
JNIEnv* env = runtime->getJNIEnv();
if (env == NULL) {
return UNKNOWN_ERROR;
}
jclass clazz = env->FindClass("com/android/server/SystemServer");
if (clazz == NULL) {
return UNKNOWN_ERROR;
}
jmethodID methodId = env->GetStaticMethodID(clazz, "init2", "()V");
if (methodId == NULL) {
return UNKNOWN_ERROR;
}
env->CallStaticVoidMethod(clazz, methodId);
ALOGI("System server: entering thread pool.\n");
ProcessState::self()->startThreadPool();
IPCThreadState::self()->joinThreadPool();
ALOGI("System server: exiting thread pool.\n");
return NO_ERROR;
}分析：
在init1函数，启动一写service（如果没有启动的话）；然后，创建一个runtime，由runtime去调用到java层的SystemServer类的init2方法；最后，将其加入线程池。
那好，我嗯再回到SystemServer类的init2方法，如下：
public static final void init2() {
Slog.i(TAG, "Entered the Android system server!");
Thread thr = new ServerThread();
thr.setName("android.server.ServerThread");
thr.start();
}在init2中，启动了ServerThread。
6）ServerThread:
所以，整个SystemServer其实，最关键的实体是这个ServerThread线程。我们之间看run函数的实现：
@Override
public void run() {
Looper.prepare();
android.os.Process.setThreadPriority(
android.os.Process.THREAD_PRIORITY_FOREGROUND);
BinderInternal.disableBackgroundScheduling(true);
android.os.Process.setCanSelfBackground(false);
LightsService lights = null;
PowerManagerService power = null;
BatteryService battery = null;
VibratorService vibrator = null;
AlarmManagerService alarm = null;
NetworkManagementService networkManagement = null;
NetworkStatsService networkStats = null;
NetworkPolicyManagerService networkPolicy = null;
ConnectivityService connectivity = null;
......
// Critical services...
try {
Slog.i(TAG, "Entropy Mixer");
ServiceManager.addService("entropy", new EntropyMixer());
Slog.i(TAG, "Power Manager");
power = new PowerManagerService();
ServiceManager.addService(Context.POWER_SERVICE, power);
......
pm = PackageManagerService.main(context,
factoryTest != SystemServer.FACTORY_TEST_OFF,
onlyCore);
boolean firstBoot = false;
try {
firstBoot = pm.isFirstBoot();
} catch (RemoteException e) {
}
ActivityManagerService.setSystemProcess();
mContentResolver = context.getContentResolver();
// The AccountManager must come before the ContentService
try {
Slog.i(TAG, "Account Manager");
ServiceManager.addService(Context.ACCOUNT_SERVICE,
new AccountManagerService(context));
} catch (Throwable e) {
Slog.e(TAG, "Failure starting Account Manager", e);
}
......
} catch (RuntimeException e) {
Slog.e("System", "******************************************");
Slog.e("System", "************ Failure starting core service", e);
}
DevicePolicyManagerService devicePolicy = null;
StatusBarManagerService statusBar = null;
InputMethodManagerService imm = null;
AppWidgetService appWidget = null;
NotificationManagerService notification = null;
WallpaperManagerService wallpaper = null;
LocationManagerService location = null;
CountryDetectorService countryDetector = null;
TextServicesManagerService tsms = null;
LockSettingsService lockSettings = null;
DreamManagerService dreamy = null;
// Bring up services needed for UI.
if (factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) {
try {
Slog.i(TAG, "Input Method Service");
imm = new InputMethodManagerService(context, wm);
ServiceManager.addService(Context.INPUT_METHOD_SERVICE, imm);
} catch (Throwable e) {
reportWtf("starting Input Manager Service", e);
}
try {
Slog.i(TAG, "Accessibility Manager");
ServiceManager.addService(Context.ACCESSIBILITY_SERVICE,
new AccessibilityManagerService(context));
} catch (Throwable e) {
reportWtf("starting Accessibility Manager", e);
}
}
try {
wm.displayReady();
} catch (Throwable e) {
reportWtf("making display ready", e);
}
try {
pm.performBootDexOpt();
} catch (Throwable e) {
reportWtf("performing boot dexopt", e);
}
try {
ActivityManagerNative.getDefault().showBootMessage(
context.getResources().getText(
com.android.internal.R.string.android_upgrading_starting_apps),
false);
} catch (RemoteException e) {
}
if (factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) {
MountService mountService = null;
if (!"0".equals(SystemProperties.get("system_init.startmountservice"))) {
try {
/*
* NotificationManagerService is dependant on MountService,
* (for media / usb notifications) so we must start MountService first.
*/
Slog.i(TAG, "Mount Service");
mountService = new MountService(context);
ServiceManager.addService("mount", mountService);
} catch (Throwable e) {
reportWtf("starting Mount Service", e);
}
}
try {
Slog.i(TAG, "LockSettingsService");
lockSettings = new LockSettingsService(context);
ServiceManager.addService("lock_settings", lockSettings);
} catch (Throwable e) {
reportWtf("starting LockSettingsService service", e);
}
try {
Slog.i(TAG, "Device Policy");
devicePolicy = new DevicePolicyManagerService(context);
ServiceManager.addService(Context.DEVICE_POLICY_SERVICE, devicePolicy);
} catch (Throwable e) {
reportWtf("starting DevicePolicyService", e);
}
......
}
// These are needed to propagate to the runnable below.
final Context contextF = context;
final BatteryService batteryF = battery;
final NetworkManagementService networkManagementF = networkManagement;
final NetworkStatsService networkStatsF = networkStats;
final NetworkPolicyManagerService networkPolicyF = networkPolicy;
final ConnectivityService connectivityF = connectivity;
final DockObserver dockF = dock;
final UsbService usbF = usb;
......
Looper.loop();
Slog.d(TAG, "System ServerThread is exiting!");
}说明：
在这个run方法中，初始化了Android系统框架层的各种service，包括：
PowerManagerService：电源管理服务
BatteryService：电池服务
PackageManagerService：包管理服务
ActivityManagerService：activity管理服务
NetworkStatsService：网络状态服务
……
这样，Android系统框架层的SystemServer进程启动完毕，许多srevice组件也都初始化好了。
至此，整个zygote就完成了它的使命，最终把Android系统框架层的SystemServer进程启动完毕做为结束点。
7）runSelectLoopMode函数:
在初始化完的SystemServer进程后，就进入一个循环中，即runSelectLoopMode函数的执行。等待客户端的请求事件，如果有请求事件，就去创建进程，这就涉及到应用进程的创建了，这部分内容在下一节讨论。
下一节：
Android系统的心脏-Zygote进程如何fork一个新的应用进程