上一篇文章我们已经分析到调用com.android.internal.os.ZygoteInit类的main函数。
今天分析一下com.android.internal.os.ZygoteInit类的main函数。
public static void main(String argv[]) {
// 注册zygote的socket
registerZygoteSocket();
//加载Android Application Framework使用的类与资源
preloadClasses();
preloadResources();
//启动SystemServer
if(argv[1].equals("true")) {
startSystemServer();
}
/**
* 处理客户端连接及请求。由zygoteConnection的runOnce函数来处理。
*/
runSelectLoopMode();
}
在main函数我们就主要看registerZygoteSocket()与runSelectLoopMode()。
- registerZygoteSocket()：就是创建一个localsocket，也就是说注册了一个zygote的服务端socket。
- runSelectLoopMode()：就是一直无限循环，等待客户端socket的连接，然后通过zygoteConnection的runOnce函数来处理对应的请求。
PreloadClass(): 读取framework/base/tools/preload/preload_class文件约1268类。
PreloadResources(): 加载framework-res.apk中的资源。
gc()：执行垃圾收集。
那么我们就看一下registerZygoteSocket()
private static void registerZygoteSocket() {
String env = System.getenv(ANDROID_SOCKET_ENV);
fileDesc = Integer.parseInt(env);
if (sServerSocket == null) {
sServerSocket = new LocalServerSocket(
createFileDescriptor(fileDesc));
}
}
很简单就是创建一个LocalServerSocket。
建立IPC通信服务器，从环境变量中获取（System.getenv(ANDROID_SOCKET_ENV);）socket的fd，之前用sig的fd来调用handle去创建的zygote。
我们在来看一下runSelectLoopMode()
private static void runSelectLoopMode() throws MethodAndArgsCaller {
…
while (true) {
int index;
fdArray = fds.toArray(fdArray);
index = selectReadable(fdArray);
if(index == ) {
//连接客户端发送的请求（Command）
ZygoteConnection newPeer = acceptCommandPeer();
peers.add(newPeer);
fds.add(newPeer.getFileDesciptor());
} else {
//处理客户端发送的请求（Command）
boolean done;
done = peers.get(index).runOnce();
}
}
}
这个函数也很简单等待客户端发来的请求，当接收到请求时就运行run0nce函数去处理请求即可。
客户端可以理解成AMS或SystemServer。
在这里简单说明一下AMS与SystemServer
-
SystemServer：
Zygote的子进程，为JAVA世界做服务。
Java世界系统Service，此进程是framework的核心，此server挂掉了，zygote会自杀。
Zygote.forkSystemServer()而诞生。
- AMS
ActivityManagerService是由SystemServer创建。
当一个Acitvity开启的时候，是由AMS中开启一个新的Process，而在Process类中最终会创建一个LocalSocket去连接ZYGOTE_SOCKET。
而在AMS中的startProcessLocked()中调用Process.start()函数中会传入一个参数-android.app.ActivityThread。最终会通过socket传入zygote处理。
我们继续看以下done = peers.get(index).runOnce();
boolean runOnce( ) {
Arguments parsedArgs = null;
FileDescriptor[] descriptors;
//Reads command socket.
args = readArgumentList();
descriptors = mSocket.getAncillaryFileDescriptors();
try {
parsedArgs = new Arguments(args);
......
pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,
parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,
parsedArgs.niceName);
} catch (IOException ex) {
......
} catch (ErrnoException ex) {
......
} catch (IllegalArgumentException ex) {
......
} catch (ZygoteSecurityException ex) {
......
}
//新创建的进程 pid == 0
if (pid == ) {
// in child
serverPipeFd = null;
handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);
return true;
} else {
// in parent，也就是Zygote进程执行过程
childPipeFd = null;
return handleParentProc(pid, descriptors, serverPipeFd, parsedArgs);
}
}
我们分析一下以下几个函数
- readArgumentList()与parsedArgs = new Arguments(args) 是用来获取command和解析command的。
- Zygote.forkAndSpecialize()是很简单的，就是去调用native函数来fork的。
- handleChildProc()是处理子进程。
- handleParentProc()是处理父进程。也就是zygote进程，此函数会原路返回，通过socket的写入返还给systemserver最终到AMS，然后重新进入runSelectLoopMode。
首先我们来看一下forkAndSpecialize()
这个函数定义在文件libcore/dalvik/src/main/java/dalvik/system/Zygote.java中。
public static int forkAndSpecialize(int uid, int gid, int[] gids, int debugFlags,
int[][] rlimits, int mountExternal, String seInfo, String niceName) {
preFork();
int pid = nativeForkAndSpecialize(uid, gid, gids, debugFlags, rlimits, mountExternal, seInfo, niceName);
postFork();
return pid;
}
很简单就是调用native的ForkAndSpecialize函数。
JNI函数nativeForkAndSpecialize的由Dalvik_dalvik_system_Zygote_forkAndSpecialize函数来实现。
那我们就去看一下。
这个函数定义在文件dalvik/vm/native/dalvik_system_Zygote.cpp中。
static void Dalvik_dalvik_system_Zygote_forkAndSpecialize(const u4* args, JValue* pResult)
{
pid_t pid;
//args指向的一块内存中
pid = forkAndSpecializeCommon(args, false); RETURN_INT(pid);
}
Dalvik_dalvik_system_Zygote_forkAndSpecialize函数通过调用forkAndSpecializeCommon函数来执行创建进程，
实现如下所示：
这个函数定义在文件dalvik/vm/native/dalvik_system_Zygote.cpp中。
static pid_t forkAndSpecializeCommon(const u4* args, bool isSystemServer)
{
pid_t pid; uid_t uid = (uid_t) args[];
gid_t gid = (gid_t) args[];
......
char *seInfo = NULL;
char *niceName = NULL; if (isSystemServer) {
//参数isSystemServer表示true时创建的是System Server进程。
......
} else {
//参数isSystemServer表示true时创建的是应用程序进程。
......
} ...... pid = fork();
//表示当前是新创建的进程
if (pid == ) {
...... err = setSELinuxContext(uid, isSystemServer, seInfo, niceName);
......
} ...... return pid;
}
我们不去看具体代码实现，主要了解一下主要是干什么的就可以了。
我们要知道的是zygote是负责应用程序进程与SystemServer的进程就可以了。
接下来我们回到之前的handleParentProc()
private boolean handleParentProc(int pid,
FileDescriptor[] descriptors, FileDescriptor pipeFd, Arguments parsedArgs) {
if (pid > ) {
setChildPgid(pid);
}
if (descriptors != null) {
for (FileDescriptor fd: descriptors) {
IoUtils.closeQuietly(fd);
}
}
boolean usingWrapper = false;
if (pipeFd != null && pid > ) {
DataInputStream is = new DataInputStream(new FileInputStream(pipeFd));
int innerPid = -;
try {
innerPid = is.readInt();
} catch (IOException ex) {
Log.w(TAG, "Error reading pid from wrapped process, child may have died", ex);
} finally {
try {
is.close();
} catch (IOException ex) {
}
}
// Ensure that the pid reported by the wrapped process is either the
// child process that we forked, or a descendant of it.
if (innerPid > ) {
int parentPid = innerPid;
while (parentPid > && parentPid != pid) {
parentPid = Process.getParentPid(parentPid);
}
if (parentPid > ) {
Log.i(TAG, "Wrapped process has pid " + innerPid);
pid = innerPid;
usingWrapper = true;
} else {
Log.w(TAG, "Wrapped process reported a pid that is not a child of "
+ "the process that we forked: childPid=" + pid
+ " innerPid=" + innerPid);
}
}
}
//将创建的应用程序进程ID返回给SystemServer进程的ActivityManagerService服务
try {
mSocketOutStream.writeInt(pid);
mSocketOutStream.writeBoolean(usingWrapper);
} catch (IOException ex) {
Log.e(TAG, "Error reading from command socket", ex);
return true;
}
/*
* If the peer wants to use the socket to wait on the
* newly spawned process, then we're all done.
*/
if (parsedArgs.peerWait) {
try {
mSocket.close();
} catch (IOException ex) {
Log.e(TAG, "Zygote: error closing sockets", ex);
}
return true;
}
return false;
}
也就是创建失败会进入此函数，也就是处理zygote进程的函数，此函数会原路返回，通过socket的写入返还给systemserver最终到AMS，然后重新进入runSelectLoopMode。继续监听客户端的请求。
如果我们新创建进程成功了，会调用handleChildProc()。
代码如下
private void handleChildProc(Arguments parsedArgs,
FileDescriptor[] descriptors, FileDescriptor pipeFd, PrintStream newStderr)
throws ZygoteInit.MethodAndArgsCaller {
/*
* Close the socket, unless we're in "peer wait" mode, in which
* case it's used to track the liveness of this process.
*/ if (parsedArgs.peerWait) {
try {
ZygoteInit.setCloseOnExec(mSocket.getFileDescriptor(), true);
sPeerWaitSocket = mSocket;
} catch (IOException ex) {
Log.e(TAG, "Zygote Child: error setting peer wait "
+ "socket to be close-on-exec", ex);
}
} else {//关闭从Zygote进程复制过来的Socket连接
closeSocket();
ZygoteInit.closeServerSocket();
}
if (descriptors != null) {
try {
//为新创建的应用程序进程重新打开标准输入输出控制台
ZygoteInit.reopenStdio(descriptors[],descriptors[], descriptors[]);
for (FileDescriptor fd: descriptors) {
IoUtils.closeQuietly(fd);
}
newStderr = System.err;
} catch (IOException ex) {
Log.e(TAG, "Error reopening stdio", ex);
}
}
//设置新进程名称
if (parsedArgs.niceName != null) {
//设置新进程名称niceName是指systemServer
Process.setArgV0(parsedArgs.niceName);
}
//重新初始化Runtime
if (parsedArgs.runtimeInit) {
if (parsedArgs.invokeWith != null) {
WrapperInit.execApplication(parsedArgs.invokeWith,
parsedArgs.niceName, parsedArgs.targetSdkVersion,
pipeFd, parsedArgs.remainingArgs);
} else {
//为应用程序进程启动Binder线程池
RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion,parsedArgs.remainingArgs);
}
} else {
String className;
try {
//读取新进程执行的类名，在Process.start()函数中，传过来的类名为："android.app.ActivityThread"
className = parsedArgs.remainingArgs[];
} catch (ArrayIndexOutOfBoundsException ex) {
logAndPrintError(newStderr,"Missing required class name argument", null);
return;
}
String[] mainArgs = new String[parsedArgs.remainingArgs.length - ];
System.arraycopy(parsedArgs.remainingArgs, ,mainArgs, , mainArgs.length);
if (parsedArgs.invokeWith != null) {
WrapperInit.execStandalone(parsedArgs.invokeWith,parsedArgs.classpath, className, mainArgs);
} else {
//获取类加载器
ClassLoader cloader;
if (parsedArgs.classpath != null) {
cloader = new PathClassLoader(parsedArgs.classpath,ClassLoader.getSystemClassLoader());
} else {
cloader = ClassLoader.getSystemClassLoader();
}
//加载并执行"android.app.ActivityThread"类
try {
ZygoteInit.invokeStaticMain(cloader, className, mainArgs);
} catch (RuntimeException ex) {
logAndPrintError(newStderr, "Error starting.", ex);
}
}
}
}
由于应用程序启动参数中已经设置了"--runtime-init"标志位，因此新创建的应用程序进程将调用RuntimeInit.zygoteInit()函数来初始化运行时库，为应用程序启动Binder线程池，完成这些准备工作后，调用应用程序进程的入口函数ActivityThread.main()为应用程序进程创建消息循环。
接下来我们就看一下RuntimeInit.zygoteInit()
此函数在/frameworks/base/core/java/com/android/internal/os/RuntimeInit.java中
public static final void zygoteInit(int targetSdkVersion, String[] argv)
throws ZygoteInit.MethodAndArgsCaller {
if (DEBUG) Slog.d(TAG, "RuntimeInit: Starting application from zygote");
//重定向Log输出流
redirectLogStreams();
//初始化运行环境
commonInit();
//启动Binder线程池
nativeZygoteInit();
//调用程序入口函数
applicationInit(targetSdkVersion, argv);
}
接下来我们看一下applicationInit()
private static void applicationInit(int targetSdkVersion, String[] argv)
throws ZygoteInit.MethodAndArgsCaller {
// If the application calls System.exit(), terminate the process
// immediately without running any shutdown hooks. It is not possible to
// shutdown an Android application gracefully. Among other things, the
// Android runtime shutdown hooks close the Binder driver, which can cause
// leftover running threads to crash before the process actually exits.
nativeSetExitWithoutCleanup(true); // We want to be fairly aggressive about heap utilization, to avoid
// holding on to a lot of memory that isn't needed.
VMRuntime.getRuntime().setTargetHeapUtilization(0.75f);
VMRuntime.getRuntime().setTargetSdkVersion(targetSdkVersion); final Arguments args;
try {
args = new Arguments(argv);
} catch (IllegalArgumentException ex) {
Slog.e(TAG, ex.getMessage());
// let the process exit
return;
} // Remaining arguments are passed to the start class's static main
invokeStaticMain(args.startClass, args.startArgs);
}
在这里我们重点要看一下invokeStaticMain()
通过调用invokeStaticMain来调用args.startClass这个类的main（）方法。
说明开启又一个新世界。
在之前提过zygote的socket的客户端可以是AMS，下一节我们分析如何开启一个Activity。