Android4.0 Zygote和启动过程
在Android系统中，所有的应用程序进程以及系统服务进程SystemServer都是由Zygote进程孕育（fork）出来的。Android系统是基于Linux内核的，而在Linux系统中，所有的进程都是init进程的子孙进程，也就是说，所有的进程都是直接或者间接地由init进程fork出来的。Zygote进程也不例外，它是在系统启动的过程，由init进程创建的。在系统启动脚本system/core/rootdir/init.rc文件中。
一、在init.rc脚本文件中：
service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
class main
socket zygote stream 666
onrestart write /sys/android_power/request_state wake
onrestart write /sys/power/state on
onrestart restart media
onrestart restart netd
service zygote init进程创建一个名为"zygote"的进程
/system/bin/app_process zygote进程要执行的程序
-Xzygote 传递给VM的选项，-Xzygote 选项用来区分要在虚拟机中运行的类是Zygote，还是在Zygote中运行的其他Android应用程序。
/system/bin 运行目录参数/system/bin 保存到 parentDir 变量中。
--zygote 用来指定加载到虚拟机中类的名称，表示加载com.android.internel.os.ZygoteInit类。
--start-system-server 作为选项传递给生成的类，用于启动运行System server。
socket zygote stream 666 套接字的名称，种类，访问权限
Zygote进程要执行的程序便是system/bin/app_process了，在frameworks/base/cmds/app_process/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++];//运行目录参数/system/bin 保存到 parentDir 变量中
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" : "");
//调用AppRuntime的start()成员函数，生成并初始化虚拟机，然后将ZygoteInit()类加载到虚拟机中，执行其中的main()方法。
} 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;
}
}
此函数主要工作：分析传递给虚拟机的参数，并保存到AppRuntime类的对象中，然后加载对象，调用对象的main()方法。
二、进入到AndroidRuntime.cpp 中start()函数中
void AndroidRuntime::start(const char* className, const char* options)
{
LOGD("\n>>>>>> AndroidRuntime START %s <<<<<<\n",
className != NULL ? className : "(unknown)");
blockSigpipe();
/*
* 'startSystemServer == true' means runtime is obsolete and not run from
* init.rc anymore, so we print out the boot start event here.
*/
if (strcmp(options, "start-system-server") == 0) {
/* track our progress through the boot sequence */
const int LOG_BOOT_PROGRESS_START = 3000;
LOG_EVENT_LONG(LOG_BOOT_PROGRESS_START,
ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
}
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);
}
//const char* kernelHack = getenv("LD_ASSUME_KERNEL");
//LOGD("Found LD_ASSUME_KERNEL='%s'\n", kernelHack);
/* start the virtual machine *///创建java虚拟机
JNIEnv* env;
if (startVm(&mJavaVM, &env) != 0) {//mJavaVM 生成的JavaVM类的接口指针，env JNIEnv类的接口指针，方便访问虚拟机
return;
}
onVmCreated(env);
/*
* Register android functions.
*/
if (startReg(env) < 0) {//注册虚拟机要使用的JNI函数，以后运行在虚拟机中的JAVA类就可以调用本地函数。
LOGE("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.
*/
char* slashClassName = toSlashClassName(className);//将类名称中的 "."替换成"/",
jclass startClass = env->FindClass(slashClassName);//在由类名称解析出来的路径下查找指定的类，若存在，测加载。
if (startClass == NULL) {
LOGE("JavaVM unable to locate class '%s'\n", slashClassName);
/* keep going */
} else {
jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
"([Ljava/lang/String;)V");//在类中查找形式参数为String数组且返回值为void的main()静态方法。
if (startMeth == NULL) {
LOGE("JavaVM unable to find main() in '%s'\n", className);
/* keep going */
} else {
env->CallStaticVoidMethod(startClass, startMeth, strArray);//找到次方法，调用此方法，此时程序的执行转到虚拟机中运行的java应用程序上。
//进入到ZygoteInit.java--ZygoteInit::main()方法中
... ...
}
}
... ...
}
三、进入到ZygoteInit.java--ZygoteInit::main()方法中
public static void main(String argv[]) {
try {
// Start profiling the zygote initialization.
SamplingProfilerIntegration.start();
registerZygoteSocket();//1、绑定套接字， 接受新android应用程序运行请求
EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,
SystemClock.uptimeMillis());
preload();//2、加载 android application framework 使用的类和资源 ，
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);
}
if (argv[1].equals("start-system-server")) {
startSystemServer();//3、运行systemserver
} 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 {
runSelectLoopMode();//4、处理新android应用程序运行请求
}
closeServerSocket();
} catch (MethodAndArgsCaller caller) {
caller.run();
} catch (RuntimeException ex) {
Log.e(TAG, "Zygote died with exception", ex);
closeServerSocket();
throw ex;
}
}
首先分析第一点：registerZygoteSocket();//1、绑定套接字， 接受新android应用程序运行请求
private static void registerZygoteSocket() {
if (sServerSocket == null) {
int fileDesc;
try {
String env = System.getenv(ANDROID_SOCKET_ENV);//获取套接字的文件描述符。它记录在ANDROID_SOCKET_zygote环境变量中。
fileDesc = Integer.parseInt(env);
} catch (RuntimeException ex) {
throw new RuntimeException(
ANDROID_SOCKET_ENV + " unset or invalid", ex);
}
try {
sServerSocket = new LocalServerSocket(
createFileDescriptor(fileDesc));//使用套接字文件描述符创建LocalServerSocket的实例，将其与/dev/socket/zygote绑定在一起
} catch (IOException ex) {
throw new RuntimeException(
"Error binding to local socket '" + fileDesc + "'", ex);
}
}
}
第二点：加载 android application framework 使用的类和资源
static void preload() {
preloadClasses();
preloadResources();
}
private static void preloadClasses() {
final VMRuntime runtime = VMRuntime.getRuntime();
InputStream is = ZygoteInit.class.getClassLoader().getResourceAsStream(
PRELOADED_CLASSES);//获取一个输入流，以便读取proloaded-classes文件中的类 ，framework/base/preloafed-classes文件。
... ...
try {
BufferedReader br
= new BufferedReader(new InputStreamReader(is), 256);//创建BufferedReader对象，并读取文件中的内容。
... ...
line = line.trim();//忽略文件中的注释和空行，读取下一行
if (line.startsWith("#") || line.equals("")) {
continue;
}
... ...
Class.forName(line);//将读取到得类动态的加载到内存中
... ...
}
第三点：运行systemserver，在ZygoteInit.java中startSystemServer（）方法中
private static boolean startSystemServer()
throws MethodAndArgsCaller, RuntimeException {
/* Hardcoded command line to start the system server */
String args[] = {
"--setuid=1000",
"--setgid=1000",
"--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,3001,3002,3003,3006,3007",
"--capabilities=130104352,130104352",
"--runtime-init",
"--nice-name=system_server",
"com.android.server.SystemServer",//用于指定systemserver类
};
... ...
pid = Zygote.forkSystemServer(
parsedArgs.uid, parsedArgs.gid,
parsedArgs.gids,
parsedArgs.debugFlags,
null,
parsedArgs.permittedCapabilities,
parsedArgs.effectiveCapabilities);//创建新进程，并运行systemserver
... ...
/* For child process */
if (pid == 0) {
handleSystemServerProcess(parsedArgs);//在生成的systemserver进程中运行com.android.server.SystemServer类的main()方法
}
... ...
}
进入handleSystemServerProcess（）中
private static void handleSystemServerProcess(
ZygoteConnection.Arguments parsedArgs)
throws ZygoteInit.MethodAndArgsCaller {
... ...
RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs);
... ...
}
进入RuntimeInit.java 中zygoteinit方法中
public static final void zygoteInit(int targetSdkVersion, String[] argv)
throws ZygoteInit.MethodAndArgsCaller {
if (DEBUG) Slog.d(TAG, "RuntimeInit: Starting application from zygote");
redirectLogStreams();
commonInit();
zygoteInitNative();//1、native层初始化
applicationInit(targetSdkVersion, argv);
}
在进入applicationInit()中
private static void applicationInit(int targetSdkVersion, String[] argv)
throws ZygoteInit.MethodAndArgsCaller {
... ...
invokeStaticMain(args.startClass, args.startArgs);
//2、调用startclass，也就是com.android.server.SystemServer类的main（）函数
}
分析上面两点：
1、native层初始化 zygoteInitNative()
public static final native void zygoteInitNative();他是一个本地函数，经过JNI调用AndroidRuntime.cpp中的
static void com_android_internal_os_RuntimeInit_zygoteInit(JNIEnv* env, jobject clazz)
{
gCurRuntime->onZygoteInit();
}
gCurRuntime是指什么？
gCurRuntime
在app_main.cpp main()函数中
int main(int argc, const char* const argv[])
{
...
AppRuntime runtime;
... ...
}
看其定义
class AppRuntime : public AndroidRuntime
继承AndroidRuntime类
static AndroidRuntime* gCurRuntime = NULL; //为全局变量
AndroidRuntime.cpp中
AndroidRuntime::AndroidRuntime()
{
SkGraphics::Init();
... ...
gCurRuntime = this; // gCurRuntime 被设置为AndroidRuntime对象自己
}
故：此时启动App_main.cpp中onZygoteInit()函数
virtual void onZygoteInit()
{
sp<ProcessState> proc = ProcessState::self();
LOGV("App process: starting thread pool.\n");
proc->startThreadPool();//启动一个线程，用于binder通信
}
2、invokeStaticMain(args.startClass, args.startArgs)
调用startclass，也就是com.android.server.SystemServer类的main（）函数
private static void invokeStaticMain(String className, String[] argv)
throws ZygoteInit.MethodAndArgsCaller {
... ...
m = cl.getMethod("main", new Class[] { String[].class });
//找到com.android.server.SystemServer类的main（）函数
... ...
throw new ZygoteInit.MethodAndArgsCaller(m, argv);//抛出一个异常
}
将在ZygoteInit的main函数中截获到，
ZygoteInit.java的main（）中
public static void main(String argv[]) {
... ...
try {
... ...
if (argv[1].equals("start-system-server")) {
startSystemServer();//运行systemserver 在此中抛出一个异常
} else if (!argv[1].equals("")) {
throw new RuntimeException(argv[0] + USAGE_STRING);
}
} catch (MethodAndArgsCaller caller) {
caller.run();
... ...
}
将进入MethodAndArgsCaller 的run函数
public void run() {
try {
//mMethod为com.android.server.SystemServer的main（）函数
mMethod.invoke(null, new Object[] { mArgs });
} catch (IllegalAccessException ex) {
throw new RuntimeException(ex);
} catch (InvocationTargetException ex) {
... ...
}
现在进入到SystemServer.java的main中
public static void main(String[] args) {
... ...
VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);
System.loadLibrary("android_servers");//加载android_servers本地库文件
init1(args);
}
进入init1（）为本地方法，将进入
native public static void init1(String[] args);
com_android_server_SystemServer.cpp中的
static void android_server_SystemServer_init1(JNIEnv* env, jobject clazz)
{
system_init();
}
extern "C" int system_init();将调用system_init.cpp中的system_init(0函数
extern "C" status_t system_init(){
... ...
property_get("system_init.startsurfaceflinger", propBuf, "1");
if (strcmp(propBuf, "1") == 0) {
// Start the SurfaceFlinger
SurfaceFlinger::instantiate();//注册本地服务
}
......
jmethodID methodId = env->GetStaticMethodID(clazz, "init2", "()V");//调用init2()方法
... ...
}
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();/创建一个线程android.server.ServerThread，并启动它
}
第四点：处理新android应用程序运行请求 runSelectLoopMode()
private static void runSelectLoopMode() throws MethodAndArgsCaller {
... ...
fds.add(sServerSocket.getFileDescriptor());//将套接字的描述符添加到描述符数组中
......
boolean done;
done = peers.get(index).runOnce();//处理新连接的输入输出套接字，并生成新的android应用程序。
... ...
}
进入zygoteconnection.java中的runonce()中
boolean runOnce() throws ZygoteInit.MethodAndArgsCaller {
.... ...
args = readArgumentList();//读取请求信息，请求信息包含创建新进程的参数选项
... ...
parsedArgs = new Arguments(args);//分析请求信息中的字符数组，为运行进程设置好各个选项
... ...
pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid,
parsedArgs.gids, parsedArgs.debugFlags, rlimits);//创建新进程
if (pid == 0) {
// in child
IoUtils.closeQuietly(serverPipeFd);//
serverPipeFd = null;
handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);//加载新进程所需的类，并调用类的main()方法。启动新的应用程序。子进程处理
// should never get here, the child is expected to either
// throw ZygoteInit.MethodAndArgsCaller or exec().
return true;
} else {
// in parent...pid of < 0 means failure
IoUtils.closeQuietly(childPipeFd);
childPipeFd = null;
return handleParentProc(pid, descriptors, serverPipeFd, parsedArgs);//zygote进程
}
}
进入到新进程创建的子进程中的处理 handleChildProc（）
ZygoteConnection.java
private void handleChildProc(Arguments parsedArgs,
FileDescriptor[] descriptors, FileDescriptor pipeFd, PrintStream newStderr)
throws ZygoteInit.MethodAndArgsCaller {
... ...
RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion,
parsedArgs.remainingArgs);
... ...
}
在进入到RuntimeInit.java中的zygoteinit（）方法中最终调用了
invokeStaticMain(args.startClass, args.startArgs);函数，前面已经分析。
android 启动过程
Android从Linux系统启动有4个步骤；
(1) init进程启动
(2) Native服务启动
(3) System Server，Android服务启动
(4) Home启动
SystemServer组件接下来就要通过ActivityManagerService来启动Home应用程序Launcher了，Launcher在启动的时候便会通过PackageManagerServic把系统中已经安装好的应用程序以快捷图标的形式展示在桌面上。
第一步：在上面，讲到了启动systemserver的过程
SystemServer.java的main函数
public static void main(String[] args) {
... ...
System.loadLibrary("android_servers");
init1(args);
}
启动init1（）函数，
native public static void init1(String[] args);
Init1（）是一个本地函数，将会进入到
static void android_server_SystemServer_init1(JNIEnv* env, jobject clazz)
{
system_init();
}
调用extern "C" int system_init();
会进入到System_init.cpp中的system_init中
extern "C" status_t system_init()
{
... ...
jclass clazz = env->FindClass("com/android/server/SystemServer");
if (clazz == NULL) {
return UNKNOWN_ERROR;
}
jmethodID methodId = env->GetStaticMethodID(clazz, "init2", "()V");
... ...
}
初始化一些服务后，会调用com/android/server/SystemServer类中的init2（）方法
Systemserver.java函数init2（）
public static final void init2() {
Slog.i(TAG, "Entered the Android system server!");
Thread thr = new ServerThread();//创建了一个ServerThread线程
thr.setName("android.server.ServerThread");
thr.start();
}
许多android framework服务都是在这个线程中注册的，可以查看其run方法。
如：ServiceManager，ActivityManagerService，PackageManagerService等。
第二步：
在run中将启动ActivityManagerService服务，
public void run() {
EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_SYSTEM_RUN,
SystemClock.uptimeMillis());
Looper.prepare();
... ...
Slog.i(TAG, "Activity Manager");
context = ActivityManagerService.main(factoryTest);//1、
... ...
ActivityManagerService.setSystemProcess();//2、
mContentResolver = context.getContentResolver();
... ...
ActivityManagerService.self().systemReady(new Runnable() {//3、
... ...
}
}
在上面的run方法中
1、在main（）方法中通过AThread线程对象来内部创建了一个ActivityManagerService实例，最后将其保存到成员变量mSelf 中，然后初始化其它成员变量。
2、
public static void setSystemProcess() {
try {
ActivityManagerService m = mSelf;
//将ActivityManagerService注册到server manager中区，可以通过ServiceManager.getService接口来访问这个全局唯一的ActivityManagerService实例。
ServiceManager.addService("activity", m);
ServiceManager.addService("meminfo", new MemBinder(m));
ServiceManager.addService("gfxinfo", new GraphicsBinder(m));
if (MONITOR_CPU_USAGE) {
ServiceManager.addService("cpuinfo", new CpuBinder(m));
}
ServiceManager.addService("permission", new PermissionController(m));
ApplicationInfo info =
mSelf.mContext.getPackageManager().getApplicationInfo(
"android", STOCK_PM_FLAGS);
mSystemThread.installSystemApplicationInfo(info);
//把在应用程序框架层下面的android包加载进来
... ...
}
3、最后调用systemReady方法
在ActivityManagerServcie.java
public void systemReady(final Runnable goingCallback) {
synchronized(this) {
... ...
mMainStack.resumeTopActivityLocked(null);//启动Home应用程序
... ...
}
}
第三步：
1、将会进入到ActivityStack.java resumeTopActivityLocked（）中
final boolean resumeTopActivityLocked(ActivityRecord prev) {
ActivityRecord next = topRunningActivityLocked(null);//返回的是当前系统Activity堆栈最顶端的Activity,此时还没有activity启动，故为null。
... ...
if (next == null) {
// There are no more activities! Let's just start up the
// Launcher...
if (mMainStack) {
return mService.startHomeActivityLocked();
}
}
... ...
}
2、进入到ActivityManagerService.java中的startHomeActivityLocked（）
boolean startHomeActivityLocked() {
if (mFactoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL
&& mTopAction == null) {
return false;
}
Intent intent = new Intent(
mTopAction,
mTopData != null ? Uri.parse(mTopData) : null);
intent.setComponent(mTopComponent);
if (mFactoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) {
intent.addCategory(Intent.CATEGORY_HOME);
}
ActivityInfo aInfo =
intent.resolveActivityInfo(mContext.getPackageManager(),
STOCK_PM_FLAGS);//向PackageManagerService查询Category类型为HOME的Activity。（AndroidManifest.xml中）
if (aInfo != null) {
intent.setComponent(new ComponentName(
aInfo.applicationInfo.packageName, aInfo.name));
// Don't do this if the home app is currently being
// instrumented.
ProcessRecord app = getProcessRecordLocked(aInfo.processName,
aInfo.applicationInfo.uid);//第一次启动这个Activity，故app为null。
if (app == null || app.instrumentationClass == null) {
intent.setFlags(intent.getFlags() | Intent.FLAG_ACTIVITY_NEW_TASK);
mMainStack.startActivityLocked(null, intent, null, null, 0, aInfo,
null, null, 0, 0, 0, false, false, null);//调用此函数启动这个Activity。
}
}
return true;
}
第四步、
调用此startActivityLocked函数后，就会启动com.android.launcher2.Launcher，然后调用它的Oncreate()方法。