在项目中我们有时会用到多进程,需要在 AndroidManifest 里进行声明 :
<activity
android:name=".RemoteActivity"
android:process=":remote"/>
启动这个 Activity 后,你的应用就有了两个进程,这时就有问题了,Application 类的生命周期也调用了两次了:
07-13 10:03:40.069 22804 22804 D MyApplication: onCreate
07-13 10:03:40.885 22846 22846 D MyApplication: onCreate
至于为什么 Appilication 类的生命周期为什么会被调用两次,我们需要从底层进行分析,重点是看 Appilication 实例是在什么地方创建的,创建后生命周期是如何调用的;Activity 和 Application 都是普通的类,他们是在 ActivityThread 中创建的,并且给予了它们生命周期回调;
具体 Activity 启动流程可以看 Activity的启动流程
这里分析下与 Appilication 相关的内容
AMS 在收到发起者的 startActivity 请求后执行 ActivityStackSupervisor 的 startSpecificActivityLocked 方法
void startSpecificActivityLocked(ActivityRecord r,
boolean andResume, boolean checkConfig) {
ProcessRecord app = mService.getProcessRecordLocked(r.processName,
r.info.applicationInfo.uid, true);
r.task.stack.setLaunchTime(r);
if (app != null && app.thread != null) {
try {
if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0
|| !"android".equals(r.info.packageName)) {
app.addPackage(r.info.packageName, r.info.applicationInfo.versionCode,
mService.mProcessStats);
}
realStartActivityLocked(r, app, andResume, checkConfig);
return;
} catch (RemoteException e) {
}
}
mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
"activity", r.intent.getComponent(), false, false, true);
}
这里调用了 AMS 的 getProcessRecordLocked 方法来查是否在 AMS 中有相关的记录(应用的每个进程名字都会记录在 AMS 中),如果没有,返回的 app 为 null, 这时 调用的是 startProcessLocked 方法
private final void startProcessLocked(ProcessRecord app, String hostingType,
String hostingNameStr, String abiOverride, String entryPoint, String[] entryPointArgs) {
...
if (entryPoint == null) entryPoint = "android.app.ActivityThread";
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "Start proc: " +
app.processName);
checkTime(startTime, "startProcess: asking zygote to start proc");
Process.ProcessStartResult startResult = Process.start(entryPoint,
app.processName, uid, uid, gids, debugFlags, mountExternal,
app.info.targetSdkVersion, app.info.seinfo, requiredAbi, instructionSet,
app.info.dataDir, entryPointArgs);
...
}
在这里创建了一个新的进程,并且调用了 ActivityThread 的 main 方法,在 main 方法里创建了 ActivityThread 对象,也就是说每个进程对应了一个 ActivityThread 对象,然后 AMS 会通知 ActivityThread 的 handleLaunchActivity 来启动 Activity:
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
...
Activity a = performLaunchActivity(r, customIntent);
...
}
在这里调用 performLaunchActivity 创建了一个 Activity 和 Application
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
...
Activity activity = null;
try {
java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
...
} catch (Exception e) {
...
}
try {
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
...
if (activity != null) {
...
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
return activity;
}
在这里先创建了 Activity 实例,再创建 Appilication 实例,并调用了 Activity 的 onCreate 方法,其中,在 makeApplication 里调用了 Application 的 onCreate 方法:
public Application makeApplication(boolean forceDefaultAppClass,
Instrumentation instrumentation) {
...
app = mActivityThread.mInstrumentation.newApplication(
cl, appClass, appContext);
...
instrumentation.callApplicationOnCreate(app);
return app;
}
总结下,由于创建了新的进程,每个进程会创建自己的 ActivityThread 实例,每个 ActivityThread 又会创建自己的 Application 实例并且会调用它的 onCreate 方法;也就是说每个进程都会有自己的 Appilication 实例,而这个实例都用的同一个类来创建的,所以你在这个类里面写的东西当然会被执行多次;
所以这就是为什么同一个应用多进程会造成 Application 的生命周期方法会调用多次;
解决办法是在 Application 的生命周期方法里对进程名进行判断,如果不是同进程就不要执行一些不必要的东西了