注意用词: 是进程的启动过程(是一个动态的过程)
用词的区别:
- 应用程序进程启动: 整个进程启动过程
- 应用程序启动: Activity启动过程
启动过程:
- AMS启动应用程序时会检查该应用程序所需要的应用程序进程是否存在, 不存在则会请求Zygote进程启动所需要的应用程序进程.
- Zygote的Java框架层创建了一个Server端的Socket, 该Socket用来等待AMS请求Zygote创建新的应用程序进程.
- Zygote通过fork自身创建应用程序进程, 这样应用进程就会获得Zygote进程在启动时创建的虚拟机实例.
- 应用程序进程创建过程中除了获取虚拟机实例外, 还创建了Binder线程池和消息循环, 这样进程可以通过Binder进行进程通信以及处理消息
示意图
应用程序进程启动过程介绍
分为两个部分:
- AMS发送启动应用程序进程请求
- Zygote接收请求并创建应用程序进程
AMS发送启动应用程序进程请求
请求时序图
AMS调用startProcessLocked()
路径: /frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
功能: AMS的逻辑, 向Zygote发送创建进程请求
逻辑:
- 注释一: 创建应用程序进程的userId
- 注释二: 对用户组ID(gids)创建和赋值
- 注释三: 如果entryPoint为null, 则赋值android.app.ActivityThread, 这个值是应用程序进程的主线程类名
- 注释四: 调用Process的start方法, 将此前得到的应用程序进程userId和gids传进去, entryPoint是主线程类名
private final void startProcessLocked(ProcessRecord app, String hostingType,
String hostingNameStr, String abiOverride, String entryPoint, String[] entryPointArgs) {
....
try {
try {
// 获取要创建的应用程序进程的用于ID
final int userId = UserHandle.getUserId(app.uid); // 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
AppGlobals.getPackageManager().checkPackageStartable(app.info.packageName, userId);
} catch (RemoteException e) {
throw e.rethrowAsRuntimeException();
}
int uid = app.uid;
int[] gids = null;
int mountExternal = Zygote.MOUNT_EXTERNAL_NONE;
if (!app.isolated) {
...
// 对gids进行创建和赋值 2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222
if (ArrayUtils.isEmpty(permGids)) {
gids = new int[3];
} else {
gids = new int[permGids.length + 3];
System.arraycopy(permGids, 0, gids, 3, permGids.length);
}
gids[0] = UserHandle.getSharedAppGid(UserHandle.getAppId(uid));
gids[1] = UserHandle.getCacheAppGid(UserHandle.getAppId(uid));
gids[2] = UserHandle.getUserGid(UserHandle.getUserId(uid));
}
if (entryPoint == null) entryPoint = "android.app.ActivityThread"; // 33333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "Start proc: " +
app.processName);
checkTime(startTime, "startProcess: asking zygote to start proc");
ProcessStartResult startResult;
if (hostingType.equals("webview_service")) {
startResult = startWebView(entryPoint,
app.processName, uid, uid, gids, debugFlags, mountExternal,
app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
app.info.dataDir, null, entryPointArgs);
} else {
// 启动应用程序进程 4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444
startResult = Process.start(entryPoint,
app.processName, uid, uid, gids, debugFlags, mountExternal,
app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
app.info.dataDir, invokeWith, entryPointArgs);
}
....
} catch (RuntimeException e) {
....
}
}
start()
路径: /frameworks/base/core/java/android/os/Process.java
功能: 调用ZygoteProcess对象的start()方法
逻辑:
- 调用ZygoteProcess对象的start()方法
public static final ProcessStartResult start(final String processClass,
final String niceName,
int uid, int gid, int[] gids,
int debugFlags, int mountExternal,
int targetSdkVersion,
String seInfo,
String abi,
String instructionSet,
String appDataDir,
String invokeWith,
String[] zygoteArgs) {
return zygoteProcess.start(processClass, niceName, uid, gid, gids,
debugFlags, mountExternal, targetSdkVersion, seInfo,
abi, instructionSet, appDataDir, invokeWith, zygoteArgs);
}
ZygoteProcess.start()
路径: /frameworks/base/core/java/android/os/ZygoteProcess.java
功能:
- 类功能: 用于保持Zygote进程的通信状态
- start()方法功能: 调用startViaZygote()方法
逻辑:
- 调用startViaZygote()方法
public final Process.ProcessStartResult start(final String processClass,
final String niceName,
int uid, int gid, int[] gids,
int debugFlags, int mountExternal,
int targetSdkVersion,
String seInfo,
String abi,
String instructionSet,
String appDataDir,
String invokeWith,
String[] zygoteArgs) {
try {
return startViaZygote(processClass, niceName, uid, gid, gids,
debugFlags, mountExternal, targetSdkVersion, seInfo,
abi, instructionSet, appDataDir, invokeWith, zygoteArgs);
} catch (ZygoteStartFailedEx ex) {
Log.e(LOG_TAG,
"Starting VM process through Zygote failed");
throw new RuntimeException(
"Starting VM process through Zygote failed", ex);
}
}
startViaZygote()
路径: /frameworks/base/core/java/android/os/ZygoteProcess.java
功能: 创建一个字符串列表, 保存应用进程启动参数
逻辑:
- 创建字符串列表
- 多个if判断是否添加参数
- 调用
zygoteSendArgsAndGetResult()方法
private Process.ProcessStartResult startViaZygote(final String processClass,
final String niceName,
final int uid, final int gid,
final int[] gids,
int debugFlags, int mountExternal,
int targetSdkVersion,
String seInfo,
String abi,
String instructionSet,
String appDataDir,
String invokeWith,
String[] extraArgs)
throws ZygoteStartFailedEx {
// 创建字符串列表argsForZygote, 保存应用进程启动参数 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
ArrayList<String> argsForZygote = new ArrayList<String>();
argsForZygote.add("--runtime-args");
argsForZygote.add("--setuid=" + uid);
argsForZygote.add("--setgid=" + gid);
if ((debugFlags & Zygote.DEBUG_ENABLE_JNI_LOGGING) != 0) {
argsForZygote.add("--enable-jni-logging");
}
....
argsForZygote.add("--target-sdk-version=" + targetSdkVersion);
....
synchronized(mLock) {
return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi), argsForZygote);
}
}
zygoteSendArgsAndGetResult()
路径: /frameworks/base/core/java/android/os/ZygoteProcess.java
参数:
- zygoteState: openZygoteSocketIfNeeded方法的返回值, 内部类, 表示与Zygote通信状态
- argsForZygote: 就是前面保存启动参数的字符串列表
功能: 将启动参数写入ZygoteState中 (ZygoteState是ZygoteProcess的静态内部类, 表示Zygote进程通信状态),
逻辑:
@GuardedBy("mLock")
private static Process.ProcessStartResult zygoteSendArgsAndGetResult(
ZygoteState zygoteState, ArrayList<String> args)
throws ZygoteStartFailedEx {
try {
int sz = args.size();
for (int i = 0; i < sz; i++) {
if (args.get(i).indexOf('\n') >= 0) {
throw new ZygoteStartFailedEx("embedded newlines not allowed");
}
}
final BufferedWriter writer = zygoteState.writer;
final DataInputStream inputStream = zygoteState.inputStream;
writer.write(Integer.toString(args.size()));
writer.newLine();
for (int i = 0; i < sz; i++) {
String arg = args.get(i);
writer.write(arg);
writer.newLine();
}
writer.flush();
Process.ProcessStartResult result = new Process.ProcessStartResult();
result.pid = inputStream.readInt();
result.usingWrapper = inputStream.readBoolean();
if (result.pid < 0) {
throw new ZygoteStartFailedEx("fork() failed");
}
return result;
} catch (IOException ex) {
zygoteState.close();
throw new ZygoteStartFailedEx(ex);
}
}
openZygoteSocketIfNeeded()
路径: /frameworks/base/core/java/android/os/ZygoteProcess.java
功能: 上面一个函数的参数获取函数, 返回ZygoteState对象
逻辑:
-
注释一: ZygoteState的connect方法会与名称为常量
ZYGOTE_SOCKET = "zygote"的Server端Socket连接 (registerZygoteSocket创建服务端Socket等待AMS (java)) -
注释二: 如果primaryZygoteState与启动应用程序进程所需ABI不匹配
- 注释三: 则与"zygote_secondary"的Socket连接
- 前面提到过Zygote的启动脚本有多个: 32位, 64位, 以及混合模式, 其中混合模式Zygote根据位分为: 主模式和辅模式, 这里筛选的就是主模式Zygote和辅模式Zygote区分不同位数的应用程序
-
注释四: 如果主模式和辅模式都不匹配则抛出异常
@GuardedBy("mLock")
private ZygoteState openZygoteSocketIfNeeded(String abi) throws ZygoteStartFailedEx {
Preconditions.checkState(Thread.holdsLock(mLock), "ZygoteProcess lock not held");
if (primaryZygoteState == null || primaryZygoteState.isClosed()) {
try {
// 与Zygote建立Socket连接
primaryZygoteState = ZygoteState.connect(mSocket); // 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
} catch (IOException ioe) {
throw new ZygoteStartFailedEx("Error connecting to primary zygote", ioe);
}
}
// 连接Zygote主模式返回的ZygoteState, 是否与启动应用程序进程所需的ABI匹配
if (primaryZygoteState.matches(abi)) { // 2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222
return primaryZygoteState;
}
// 如果不匹配, 则尝试连接Zygote辅模式
if (secondaryZygoteState == null || secondaryZygoteState.isClosed()) {
try {
secondaryZygoteState = ZygoteState.connect(mSecondarySocket); // 3333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333
} catch (IOException ioe) {
throw new ZygoteStartFailedEx("Error connecting to secondary zygote", ioe);
}
}
// 连接Zygote辅模式返回的ZygoteState是否与启动应用程序进程所需的ABI匹配
if (secondaryZygoteState.matches(abi)) { // 4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444
return secondaryZygoteState;
}
throw new ZygoteStartFailedEx("Unsupported zygote ABI: " + abi);
}
Zygote接收请求并创建应用程序进程
时序图
ZygoteInit.main()
前置:
-
openZygoteSocketIfNeeded()通过ZygoteState与Zygote进程建立连接 - 上面的返回值传递给
zygoteSendArgsAndGetResult(), 同时还传递了启动参数, 然后将启动参数写入ZygoteState - 写入后, Zygote进程就会收到创建应用程序进程的请求
路径: /frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
功能: 主要功能在ZygoteInit (Java) 有介绍
逻辑: 只讨论创建新进程相关的逻辑
- 注释4: 调用runSelectLoop()方法, 等待AMS请求创建新的应用程序进程
public static void main(String argv[]) {
....
try {
....
// 创建一个Server端的Socket, socketName为"zygote"
zygoteServer.registerServerSocket(socketName);
// In some configurations, we avoid preloading resources and classes eagerly.
// In such cases, we will preload things prior to our first fork.
if (!enableLazyPreload) {
bootTimingsTraceLog.traceBegin("ZygotePreload");
EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,
SystemClock.uptimeMillis());
preload(bootTimingsTraceLog);
EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,
SystemClock.uptimeMillis());
bootTimingsTraceLog.traceEnd(); // ZygotePreload
} else {
Zygote.resetNicePriority();
}
....
if (startSystemServer) {
startSystemServer(abiList, socketName, zygoteServer);
}
Log.i(TAG, "Accepting command socket connections");
zygoteServer.runSelectLoop(abiList); // 4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444
zygoteServer.closeServerSocket();
} catch (Zygote.MethodAndArgsCaller caller) {
caller.run();
} catch (Throwable ex) {
Log.e(TAG, "System zygote died with exception", ex);
zygoteServer.closeServerSocket();
throw ex;
}
}
runSelectLoop()
路径: /frameworks/base/core/java/com/android/internal/os/ZygoteServer.java
功能: 循环等待AMS请求, 并给出回调函数
逻辑:
- 注释一: ZygoteConnection列表peers, 应该表示
- 注释二: 调用ZygoteConnection的runOnce()处理请求数据
void runSelectLoop(String abiList) throws Zygote.MethodAndArgsCaller {
ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>(); // 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
fds.add(mServerSocket.getFileDescriptor());
peers.add(null);
while (true) {
StructPollfd[] pollFds = new StructPollfd[fds.size()];
for (int i = 0; i < pollFds.length; ++i) {
pollFds[i] = new StructPollfd();
pollFds[i].fd = fds.get(i);
pollFds[i].events = (short) POLLIN;
}
try {
Os.poll(pollFds, -1);
} catch (ErrnoException ex) {
throw new RuntimeException("poll failed", ex);
}
for (int i = pollFds.length - 1; i >= 0; --i) {
if ((pollFds[i].revents & POLLIN) == 0) {
continue;
}
if (i == 0) {
ZygoteConnection newPeer = acceptCommandPeer(abiList);
peers.add(newPeer);
fds.add(newPeer.getFileDesciptor());
} else {
boolean done = peers.get(i).runOnce(this); // 22222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222
if (done) {
peers.remove(i);
fds.remove(i);
}
}
}
}
}
runOnce()
路径: /frameworks/base/core/java/com/android/internal/os/ZygoteConnection.java
功能: 创建应用程序进程
逻辑:
-
注释一: readArgumentList()获取启动参数
-
注释二: 将启动参数封装到Arguments对象
-
注释三: 调用Zygote的forkAndSpecialize方法创建应用程序进程 (传入应用进程启动参数)
-
通过pid划分子进程逻辑:
- 调用handleChildProc()处理应用程序进程
boolean runOnce(ZygoteServer zygoteServer) throws Zygote.MethodAndArgsCaller {
String args[];
Arguments parsedArgs = null;
FileDescriptor[] descriptors;
try {
// 获取应用程序进程启动参数
args = readArgumentList(); // 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
descriptors = mSocket.getAncillaryFileDescriptors();
} catch (IOException ex) {
Log.w(TAG, "IOException on command socket " + ex.getMessage());
closeSocket();
return true;
}
try {
parsedArgs = new Arguments(args); // 2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222
....
// 创建应用程序进程 333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333
pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,
parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,
parsedArgs.niceName, fdsToClose, fdsToIgnore, parsedArgs.instructionSet,
parsedArgs.appDataDir);
} catch (ErrnoException ex) {
logAndPrintError(newStderr, "Exception creating pipe", ex);
}
....
try {
if (pid == 0) {
// 子进程
zygoteServer.closeServerSocket();
IoUtils.closeQuietly(serverPipeFd);
serverPipeFd = null;
// 处理应用程序进程
handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);
return true;
} else {
// in parent...pid of < 0 means failure
IoUtils.closeQuietly(childPipeFd);
childPipeFd = null;
return handleParentProc(pid, descriptors, serverPipeFd, parsedArgs);
}
} finally {
IoUtils.closeQuietly(childPipeFd);
IoUtils.closeQuietly(serverPipeFd);
}
}
handleChildProc
路径: /frameworks/base/core/java/com/android/internal/os/ZygoteConnection.java
功能: 处理应用程序进程
逻辑:
- 注释一: 调用ZygoteInit的zygoteInit()方法
private void handleChildProc(Arguments parsedArgs,
FileDescriptor[] descriptors, FileDescriptor pipeFd, PrintStream newStderr)
throws Zygote.MethodAndArgsCaller {
if (parsedArgs.invokeWith != null) {
WrapperInit.execApplication(parsedArgs.invokeWith,
parsedArgs.niceName, parsedArgs.targetSdkVersion,
VMRuntime.getCurrentInstructionSet(),
pipeFd, parsedArgs.remainingArgs);
} else {
ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion,
parsedArgs.remainingArgs, null /* classLoader */); // 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
}
}
zygoteInit()
路径: /frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
功能: 处理应用程序进程
逻辑:
- 注释一: 创建Binder线程池
- 注释二: 调用RuntimeInit的applicationInit()方法
public static final void zygoteInit(int targetSdkVersion, String[] argv,
ClassLoader classLoader) throws Zygote.MethodAndArgsCaller {
if (RuntimeInit.DEBUG) {
Slog.d(RuntimeInit.TAG, "RuntimeInit: Starting application from zygote");
}
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ZygoteInit");
RuntimeInit.redirectLogStreams();
RuntimeInit.commonInit();
ZygoteInit.nativeZygoteInit(); // 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader); // 222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222
}
applicationInit()
路径: /frameworks/base/core/java/com/android/internal/os/RuntimeInit.java
功能: 调用invokeStaticMain()方法
逻辑:
-
注释一: 调用invokeStaticMain()方法
- 参数args.startClass = andoir.app.ActivityThread (定义在AMS调用startProcessLocked())
protected static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
throws Zygote.MethodAndArgsCaller {
nativeSetExitWithoutCleanup(true);
....
final Arguments args;
try {
args = new Arguments(argv);
} catch (IllegalArgumentException ex) {
Slog.e(TAG, ex.getMessage());
return;
}
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
invokeStaticMain(args.startClass, args.startArgs, classLoader); // 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
}
invokeStaticMain()
路径: /frameworks/base/core/java/com/android/internal/os/RuntimeInit.java
功能: 调用ActivityThread的main方法
逻辑:
- 注释一: 通过反射得到android.app.ActivityThread类
- 注释二: 获得ActivityThread的main方法
- 抛出异常调用main方法(跟前面启动SystemServer一样)
private static void invokeStaticMain(String className, String[] argv, ClassLoader classLoader)
throws Zygote.MethodAndArgsCaller {
Class<?> cl;
try {
// 获得andorid.app.ActivityThread类
cl = Class.forName(className, true, classLoader); // 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
} catch (ClassNotFoundException ex) {
throw new RuntimeException(
"Missing class when invoking static main " + className,
ex);
}
Method m;
try {
// 获得ActivityThread的main方法
m = cl.getMethod("main", new Class[] { String[].class }); // 22222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222
} 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);
}
/*
* This throw gets caught in ZygoteInit.main(), which responds
* by invoking the exception's run() method. This arrangement
* clears up all the stack frames that were required in setting
* up the process.
*/
throw new Zygote.MethodAndArgsCaller(m, argv); // 3333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333
}
main()
路径: /frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
功能: 由于invokeStaticMain()以异常的方式调用ActivityThread的main(), 所以需要在ZygoteInit中找到处理该异常的语句
逻辑:
- 注释一: 调用caller的run()
public static void main(String argv[]) {
....
try {
....
} catch (Zygote.MethodAndArgsCaller caller) {
caller.run(); // 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
} catch (Throwable ex) {
Log.e(TAG, "System zygote died with exception", ex);
zygoteServer.closeServerSocket();
throw ex;
}
}
run()
路径: /frameworks/base/core/java/com/android/internal/os/Zygote.java
功能:
逻辑:
- 位于MethodAndArgsCaller内部类中
- 注释一: 调用mMethod.invoke(), 其中mMethod就是ActivityThread的main方法, 调用该方法后main方法被动态调用
public static class MethodAndArgsCaller extends Exception
implements Runnable {
/** method to call */
private final Method mMethod;
/** argument array */
private final String[] mArgs;
public MethodAndArgsCaller(Method method, String[] args) {
mMethod = method;
mArgs = args;
}
public void run() {
try {
mMethod.invoke(null, new Object[] { mArgs }); // 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
} 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);
}
}
}
Binder线程池启动过程
在zygoteInit()中启动了Binder线程池, 这里看看详细过程
启动
回顾zygoteInit()中的代码
逻辑:
- 注释一: 调用nativeZygoteInit() 创建Binder线程池
public static final void zygoteInit(int targetSdkVersion, String[] argv,
ClassLoader classLoader) throws Zygote.MethodAndArgsCaller {
if (RuntimeInit.DEBUG) {
Slog.d(RuntimeInit.TAG, "RuntimeInit: Starting application from zygote");
}
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ZygoteInit");
RuntimeInit.redirectLogStreams();
RuntimeInit.commonInit();
ZygoteInit.nativeZygoteInit(); // 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader); // 222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222
}
nativeZygoteInit()
路径: /frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
功能: 一个native方法, 进行跟进
private static fianl native void nativeZygoteInit();
com_android_internal_os_ZygoteInit_nativeZygoteInit()
路径: /frameworks/base/core/jni/AndroidRuntime.cpp
功能: 调用AppRuntime的onZygoteInit()方法
逻辑:
- gCurRuntime是AndroidRuntime类型指针, 在AndroidRuntime初始化创建.
- AppRuntime是AndroidRuntime子类, AppRuntime创建时调用父类构造方法
- gCurRuntime就被初始化, 并指向AppRuntime
static void com_android_internal_os_ZygoteInit_nativeZygoteInit(JNIEnv* env, jobject clazz)
{
gCurRuntime->onZygoteInit();
}
onZygoteInit()
路径: /frameworks/base/cmds/app_process/app_main.cpp
功能: 调用ProcessState的startThreadPool函数启动Binder线程池
逻辑:
- 注释一: 调用ProcessState的startThreadPool函数启动Binder线程池
virtual void onZygoteInit()
{
sp<ProcessState> proc = ProcessState::self();
ALOGV("App process: starting thread pool.\n");
proc->startThreadPool(); // 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
}
startThreadPool()
路径: /frameworks/native/libs/binder/ProcessState.cpp
功能: 启动Binder线程池
逻辑:
- 注释一: 支持Binder通信的进程都有ProcessState类, 其中有mThreadPoolStarted变量, 标识Binder线程池是否已经被启动过了, 所以先检查该标记
- 注释二: 设置mThreadPoolStarted
- 注释三: 创建线程池的第一个线程, 也就是线程池的主线程
void ProcessState::startThreadPool()
{
AutoMutex _l(mLock);
if (!mThreadPoolStarted) { // 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
mThreadPoolStarted = true; // 222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222
spawnPooledThread(true); // 333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333
}
}
spawnPooledThread()
路径: /frameworks/native/libs/binder/ProcessState.cpp
功能: Binder线程是一个PoolThread, 在注释一处调用PoolThread对象的run()
void ProcessState::spawnPooledThread(bool isMain)
{
if (mThreadPoolStarted) {
String8 name = makeBinderThreadName();
ALOGV("Spawning new pooled thread, name=%s\n", name.string());
sp<Thread> t = new PoolThread(isMain);
t->run(name.string()); // 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
}
}
run()
路径: /frameworks/native/libs/binder/ProcessState.cpp
功能:
- PoolThread是Thread子类
- 注释一: 调用IPCThreadState的joinThreadPool(), 将当前线程注册到Binder驱动程序中, 这样创建的线程加入了Binder线程池中.
- 然后进程即可支持通信了
class PoolThread : public Thread
{
protected:
virtual bool threadLoop()
{
IPCThreadState::self()->joinThreadPool(mIsMain); // 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
return false;
}
const bool mIsMain;
};
消息循环创建过程
先不看了
原文
- Android进阶解密