点击桌面图标打开一个应用,系统可能先发现目标进程不存在,于是创建进程并进入 ActivityThread.main()。但这个 main() 不是首页 Activity 的 onCreate()。如果别的应用先请求该应用的 Service 或 ContentProvider,或者系统需要投递符合条件的清单广播,也可能由这些事件先触发目标进程启动。
这就有两个问题:
- 谁负责把进程创建出来?
- 进程就绪后,谁负责把这一次请求交给具体组件?
本文以「打开一个尚未运行的 MainActivity」为入门例子,再对照 Service、ContentProvider 和 BroadcastReceiver。四种入口并不要求先有 Activity;你也会看到为什么 Provider 的 onCreate() 可能早于 Application 的 onCreate()。
先给结论:共用进程入口,组件各有调度入口
先看图 1:它只回答「目标组件所在进程尚不存在时,怎样创建并绑定新进程」。随后用文字速览四类组件在进程就绪后的调度:进程创建不是组件创建;已有进程不会再走图 1 的创建路径,也不是每次调用都会重复 bindApplication。
图 1:①处列出四类入口及其服务端处理模块;Activity、Service、Provider 的请求分别由对应模块处理,清单声明的 BroadcastReceiver 由 AMS 的广播队列安排投递。这里的 BroadcastQueueImpl 是此 AOSP 版本中 AMS 所用广播队列的具体实现;本图一次只取对应的一类入口,不是四个组件依次启动。①到②的箭头标注了继续向下的条件:目标进程未运行且请求获准启动;已有可用进程不走②—⑩这条冷启动路径。三个泳道分别展示 AMS/ProcessList、Zygote/USAP 和新应用进程的职责。编号是逻辑主线,Binder 派发与主线程执行不保证全局严格串行;省略异常、受限备份等特殊分支。
🔵 架构推断(非 AOSP 官方设计说明):在 2008 年初始公开提交 中,已有“创建 Application 对象 → 创建、初始化并发布 Provider → 调用
Application.onCreate()”的顺序;2012 年文档修订 又特意注明:Application.onCreate()在 Activity、Service、Receiver 创建前调用,ContentProvider 不在这一保证内;但这些提交并未解释为什么这样排序。结合应用侧创建并发布 Provider和服务端发布时唤醒等待方,一种合理的架构推断是:先发布 Provider,可避免其发布被应用自定义且可能耗时的Application.onCreate()阻塞,让等待它的调用方更早拿到 Provider。这只涉及等待 Provider 发布,不保证query()等实际调用立即完成;Provider 自身的onCreate()也可能耗时。这里分析的是可观察的架构效果,不是已证实的原始设计动机。
进程就绪后,四类组件各做什么?
- 🟦 Activity:需要新实例时,由
LaunchActivityItem安排创建并调用onCreate();可以复用实例时,不会仅因这次请求重建 Activity,按情况交付新 Intent。 - 🟩 Service:首次创建实例时,应用进程收到
CREATE_SERVICE消息,创建 Service 并调用onCreate();已有实例则复用,不重跑onCreate()。之后按请求类型处理:启动请求调用onStartCommand();绑定请求按状态调用onBind()/onRebind(),也可能复用已有绑定结果。 - 🟨 ContentProvider:需要新实例时,应用侧创建 Provider、调用
onCreate()并向 AMS 发布;已有实例可复用。 - 🟪 BroadcastReceiver(清单声明):系统安排投递时,应用侧实例化接收器并调用
onReceive()。
这四种组件各有自己的调度路径,并不是一次请求要依次创建四个组件。上面只概括请求到达应用进程后的处理;Service 的绑定何时会创建实例见第四节,动态注册 Receiver 的分发方式见第六节。
是否需要走图 1 的冷启动路径,要看目标组件所在进程是否已可用,不能只看应用包名。一个应用的组件默认可以共享进程,也可以通过 android:process 分属不同进程;同一包里的某个进程已经运行,不代表另一个进程不需要启动。每个新建的应用进程分别完成绑定和 Application 初始化,也不能认为整个应用包只会调用一次 Application.onCreate()。
接下来以打开 MainActivity 为例,先看系统怎样找到或创建承载它的进程,再看进程就绪后如何调度 Activity。
一、ActivityThread.main() 从哪里来?
1. 启动 MainActivity:目标进程是否已可用?
以应用内调用 startActivity() 为例,请求通常经 Instrumentation.execStartActivity() 送往 ATMS。Instrumentation 会检查服务端返回的启动请求结果;这个结果不代表目标 Activity 已经创建。桌面启动等入口也不一定经过这段客户端代码:
// Instrumentation.execStartActivity(),节选
int result = ActivityTaskManager.getService().startActivity(whoThread,
who.getOpPackageName(), who.getAttributionTag(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()), token,
target != null ? target.mEmbeddedID : null, requestCode, 0, null, options);
notifyStartActivityResult(result, options);
checkStartActivityResult(result, intent);
源码:Instrumentation.execStartActivity、ATMS.startActivityAsUser。
请求进入服务端后,ATMS 需要先确定运行 MainActivity 的目标进程是否可用。在 ActivityTaskSupervisor.startSpecificActivity() 中,如果目标进程已经附着应用线程,就继续执行 realStartActivityLocked();否则请求 startProcessAsync() 启动目标进程。
// ActivityTaskSupervisor.startSpecificActivity(),节选
final WindowProcessController wpc =
mService.getProcessController(r.processName, r.getUid());
if (wpc != null && wpc.hasThread()) {
try {
realStartActivityLocked(r, wpc, andResume, checkConfig);
return;
} catch (RemoteException e) {
Slog.w(TAG, "Exception when starting activity "
+ r.intent.getComponent().flattenToShortString(), e);
}
}
// ……省略进程异常与 SDK sandbox 分支、状态记录……
mService.startProcessAsync(r, knownToBeDead, isTop,
isTop ? HostingRecord.HOSTING_TYPE_TOP_ACTIVITY
: HostingRecord.HOSTING_TYPE_ACTIVITY);
源码:ActivityTaskSupervisor.startSpecificActivity。startProcessAsync() 经 ATMS 的内部进程启动入口 把进程启动请求交给 AMS。这是 system_server 内部的协作,并不是客户端再次调用 startActivity()。
在 ProcessList 中,普通应用进程的入口类被明确指定为 android.app.ActivityThread:
// ProcessList.startProcessLocked(),节选
final String entryPoint = "android.app.ActivityThread";
return startProcessLocked(hostingRecord, entryPoint, app, uid, gids,
runtimeFlags, zygotePolicyFlags, mountExternal, seInfo, requiredAbi,
instructionSet, invokeWith, startUptime, startElapsedTime);
源码:ProcessList:选定进程入口、ProcessList:普通路径调用 Process.start。这里传给启动流程的是进程入口类名,而不是 Activity 类名;系统还要维护进程记录和启动序号,并处理目标进程已在启动等情况。
2. Zygote 创建的是进程,不是 Activity 对象
在普通启动路径中,Process.start() 将进程入口类名和启动参数交给 Zygote。新进程随后经过 ZygoteInit.zygoteInit() 和 RuntimeInit.applicationInit(),进入该入口类的 main(String[]);Zygote 不会在创建进程时直接实例化 MainActivity。
// ZygoteInit.zygoteInit(),节选
RuntimeInit.commonInit();
ZygoteInit.nativeZygoteInit();
return RuntimeInit.applicationInit(targetSdkVersion, disabledCompatChanges,
enabledCompatChanges, argv, classLoader);
源码:Process.start、ZygoteProcess 向 Zygote 传递启动参数、子进程入口、RuntimeInit 查找静态 main。这里是逻辑主线:实际 fork 策略可能使用 USAP 或其他快速路径,不能断言每次都走同一条 forkAndSpecialize() 调用栈。
新进程进入 ActivityThread.main() 后,首先准备主线程,并通过 attach() 向 AMS 报到;此时还没有创建目标 Activity:
// ActivityThread.main(),节选
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false, startSeq);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
// ……省略日志和 Trace……
Looper.loop();
源码:ActivityThread.main。startSeq 是进程启动时传递的序号,供服务端识别本次进程附着。主线程进入 Looper.loop() 后,便在消息循环中处理后续的组件调度。
二、attachApplication 与 bindApplication:进程「报到」后做什么?
ActivityThread.attach(false, startSeq) 通过 Binder 调用 AMS:
// ActivityThread.attach(),节选
final IActivityManager mgr = ActivityManager.getService();
try {
mgr.attachApplication(mAppThread, startSeq);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
源码:ActivityThread.attach、AMS.attachApplication。mAppThread 是实现 IApplicationThread 的应用侧 Binder 对象;有了它,system_server 后续才能把工作安排给这个进程。
AMS 确认进程身份,并收集该进程需要创建的 Provider 等信息,然后调用应用侧的 thread.bindApplication(...)。这个 Binder 调用不会直接完成应用初始化;应用侧先把绑定数据交给主线程处理:
// ActivityThread.ApplicationThread.bindApplication(),节选
AppBindData data = new AppBindData();
// ……填充进程、应用、Provider 等绑定信息……
sendMessage(H.BIND_APPLICATION, data);
源码:AMS 收集 Provider 并 bindApplication、ActivityThread.ApplicationThread.bindApplication、主线程处理 BIND_APPLICATION。这里的 bindApplication 是系统把应用初始化信息交给新进程,不是调用 Context.bindService() 绑定 Service。
主线程处理 BIND_APPLICATION 时,handleBindApplication() 先创建 Application 对象并附着 Context,再创建、初始化并发布本进程需要的 Provider(如果有),最后调用 Application.onCreate():
// ActivityThread.handleBindApplication(),节选;省略中间初始化代码
app = data.info.makeApplicationInner(data.restrictedBackupMode, null);
// ……设置 Application 配置等……
mInitialApplication = app;
// ……
if (!data.restrictedBackupMode) {
if (!ArrayUtils.isEmpty(data.providers)) {
installContentProviders(app, data.providers);
}
}
// ……
mInstrumentation.callApplicationOnCreate(app);
源码:Application 创建与 Provider 初始化顺序、Instrumentation 调用 Application.onCreate。makeApplicationInner() 会实例化/缓存 Application 并 attach Context;「创建 Application 对象」和「调用 Application.onCreate()」并非同一个时间点。如果本次绑定需要创建 Provider,它的 onCreate() 可先于 Application 的 onCreate();受限备份模式等特殊分支不适用这一常规顺序。
注意:
bindApplication负责应用初始化,不会直接创建 Activity、Service 或 Receiver;这些组件由各自的调度流程处理。服务端处理进程 attach 时也可能安排组件事务,因此图 1 的编号表示逻辑主线,不保证跨 Binder 的调度严格逐步串行。
三、Activity:启动事务如何创建目标实例
目标进程可用后,ATMS 在 realStartActivityLocked() 中创建 LaunchActivityItem,再按目标状态搭配 ResumeActivityItem 等生命周期项,将 Activity 启动事务交给该进程。这一步调度的是组件,不会再次创建应用进程。
// ActivityTaskSupervisor.realStartActivityLocked(),节选
final LaunchActivityItem launchActivityItem = new LaunchActivityItem(r.token,
r.intent, System.identityHashCode(r), r.info,
procConfig, overrideConfig, deviceId,
r.getFilteredReferrer(r.launchedFromPackage), task.voiceInteractor,
proc.getReportedProcState(), r.getSavedState(), persistentState,
results, newIntents, r.takeSceneTransitionInfo(), isTransitionForward,
proc.createProfilerInfoIfNeeded(), r.assistToken, activityClientController,
r.shareableActivityToken, r.getLaunchedFromBubble(), fragmentToken,
r.initialCallerInfoAccessToken, activityWindowInfo, r.getDisplayId());
// ……根据 andResume、可见性选择不同的 lifecycleItem……
final boolean isSuccessful = mService.getLifecycleManager().scheduleTransactionItems(
proc.getThread(),
// Immediately dispatch the transaction, so that if it fails, the server can
// restart the process and retry now.
true /* shouldDispatchImmediately */,
launchActivityItem, lifecycleItem);
shouldDispatchImmediately 表示立即向客户端派发事务,不等于等待客户端同步完成 onCreate();省略的分支还可能先派发已有待处理事务。 源码:ATMS 组装 Activity 启动事务、LaunchActivityItem.execute。
客户端 IApplicationThread.scheduleTransaction() 把事务送进主线程;H.EXECUTE_TRANSACTION 执行 TransactionExecutor,LaunchActivityItem.execute() 调用 handleLaunchActivity(),最后进入 performLaunchActivity():
// ActivityThread.performLaunchActivity(),分别节选
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
// ……创建 Context、attach Activity,取得 Application 等……
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
源码:ActivityThread 消费事务、创建 Activity 实例、调用 Activity.onCreate。Instrumentation.callActivityOnCreate() 最终触发目标 Activity 的 onCreate();是否继续执行 onStart()、onResume(),由客户端事务要求的生命周期状态决定,并不是 ActivityThread.main() 直接调用这些回调。
这里还要分清两层复用:目标进程已可用时,不必再通过 Zygote 创建进程;目标 Activity 实例可复用时,也可能只需交付新的 Intent,并按条件调用 onNewIntent(),不再创建 Activity 对象。即使调用方的 startActivity() 已返回,也不能据此认定目标 Activity 完成了 onCreate()、绘制了首帧或已经可见。
四、Service:何时创建实例,如何处理启动和绑定请求
启动 Service 不需要先创建 Activity。startService() 和 bindService() 的请求由 AMS 中的 ActiveServices 处理;请求获准且需要新建 Service 实例时,服务端通过 bringUpServiceLocked() 查找或启动目标进程,进程可用后再由 realStartServiceLocked() 安排 scheduleCreateService()。
如果只调用不带 BIND_AUTO_CREATE 的 bindService(),而 Service 实例尚未创建,系统不会仅因这次绑定就创建实例或启动目标进程;如果实例已经存在,则可以向它发起绑定。之后若有其他请求创建了该 Service,先前登记的绑定也可能继续处理。
// ActiveServices.realStartServiceLocked(),节选
thread.scheduleCreateService(r, r.serviceInfo,
null /* compatInfo (unused but need to keep method signature) */,
app.getReportedProcState());
源码:startServiceLocked、bindServiceLocked、bringUpServiceLocked、realStartServiceLocked 调度创建。
服务端调用 scheduleCreateService() 后,应用侧把 CREATE_SERVICE 消息交给主线程。主线程在 handleCreateService() 中实例化 Service、附着 Context,最后调用 service.onCreate():
// ActivityThread.handleCreateService(),节选
Application app = packageInfo.makeApplicationInner(false, mInstrumentation);
// ……获取 ClassLoader……
service = packageInfo.getAppFactory()
.instantiateService(cl, data.info.name, data.intent);
// ……创建 Service Context……
service.attach(context, this, data.info.name, data.token, app,
ActivityManager.getService());
// ……
service.onCreate();
源码:客户端接收 CREATE_SERVICE、ActivityThread.handleCreateService。这里再次调用 makeApplicationInner() 并不意味着每启动一个 Service 都会重新执行 Application 的 onCreate();已有的 Application 实例会被复用。
服务端安排创建 Service 后,还会根据启动或绑定请求发送后续消息。应用主线程先执行 Service.onCreate(),再处理相应消息;同一个实例也可能同时处于已启动和已绑定状态:
- 启动请求:服务端通过
scheduleServiceArgs()交付启动参数,应用侧的handleServiceArgs()调用s.onStartCommand(...)。 - 绑定请求:首次建立绑定时,
handleBindService()调用s.onBind(...)并向 AMSpublishService(...);重新绑定时可能调用onRebind(),已有绑定结果也可能直接复用。连接方收到绑定结果后,才执行其服务连接回调。
// ActivityThread.handleBindService() / handleServiceArgs(),分别节选
IBinder binder = s.onBind(data.intent);
ActivityManager.getService().publishService(
data.token, data.bindToken, binder);
// ……另一条调度路径……
res = s.onStartCommand(data.args, data.flags, data.startId);
源码:服务端安排 bind、服务端安排 start 参数、客户端 onBind / publishService、客户端 onStartCommand。如果新建 Service 时启动和绑定请求都在等待,系统会为同一个实例安排创建及两类后续回调。但这不代表 onBind() 在所有情况下都早于 onStartCommand():已经运行的启动型 Service 也可能稍后才收到绑定请求。只绑定不意味着会执行 onStartCommand(),只启动也不意味着会执行 onBind();Service.onCreate() 只在实例创建时调用,不会因每次 start 或 bind 都重跑。
五、ContentProvider:访问如何拉起进程,何时调用 onCreate()
Provider 的路径尤其能说明:启动进程和创建目标组件是两回事。即使这次请求是打开 MainActivity,目标进程也可能在处理 bindApplication 时先创建并初始化同进程的 Provider;Activity 实例则在主线程执行启动事务时创建。反过来,其他应用先访问 Provider,也可能因此拉起目标进程,而不需要 Activity 启动请求。
调用方会先检查本进程是否已缓存目标 Provider;若没有,ActivityThread.acquireProvider() 再向 AMS 请求。如果目标 Provider 尚未发布,调用方可能需要等待,直至它发布或等待超时:
// ActivityThread.acquireProvider(),节选
final IContentProvider provider = acquireExistingProvider(c, auth, userId, stable);
if (provider != null) {
return provider;
}
// ……
holder = ActivityManager.getService().getContentProvider(
getApplicationThread(), c.getOpPackageName(), auth, userId, stable);
源码:客户端获取 Provider 与等待发布。服务端 ContentProviderHelper.getContentProviderImpl() 再区分已有承载进程和冷进程:
// ContentProviderHelper.getContentProviderImpl(),节选
if (proc != null && (thread = proc.getThread()) != null
&& !proc.isKilled()) {
if (mService.mProcessStateController.addPublishedProvider(proc,
cpi.name, cpr)) {
// ……临时解冻进程……
try {
thread.scheduleInstallProvider(cpi);
} catch (RemoteException e) {
}
}
} else {
// ……省略状态和统计……
final HostingRecord hostingRecord = HostingRecord.forContentProvider(
new ComponentName(cpi.applicationInfo.packageName, cpi.name),
cpi.shouldRunInPccSandbox(),
callingUid, r != null ? r.processName : null,
name, stable);
proc = mService.startProcessLocked(
cpi.processName, cpr.mAppInfo, false, 0,
hostingRecord,
Process.ZYGOTE_POLICY_FLAG_EMPTY, false, false);
}
两处代码来自同一个方法的不同分支,省略了条件检查与统计。 源码:ContentProviderHelper:已有进程或启动进程。如果 Provider 已被缓存或发布,调用方可以复用它;一次 query() 并不必然触发新进程启动。
新进程处理 bindApplication 时,如果 AMS 提供了本进程需要的 Provider 列表,installContentProviders() 会逐个调用 installProvider()。这里的「安装」是框架源码的用词,指在应用进程中创建、初始化并登记 Provider,不是安装应用 APK:localProvider.attachInfo(c, info) 会触发 ContentProvider.onCreate()。处理完列表后,应用进程再通过 publishContentProviders() 向 AMS 发布成功创建的 Provider:
// ActivityThread.installContentProviders(),节选
for (ProviderInfo cpi : providers) {
ContentProviderHolder cph = installProvider(context, null, cpi,
false /*noisy*/, true /*noReleaseNeeded*/, true /*stable*/);
if (cph != null) {
cph.noReleaseNeeded = true;
results.add(cph);
}
}
// ……
ActivityManager.getService().publishContentProviders(
getApplicationThread(), results);
再看 installProvider() 的内部实现:它创建 Provider 实例后调用 attachInfo(),而 attachInfo() 才会触发 Provider 的 onCreate():
// ActivityThread.installProvider(),节选
localProvider = packageInfo.getAppFactory()
.instantiateProvider(cl, info.name);
// ……取得 Provider 的 Binder 并进行必要检查……
localProvider.attachInfo(c, info);
// ContentProvider.attachInfo(),节选;与上方不是同一个方法
ContentProvider.this.onCreate();
源码:创建并发布 Provider、instantiateProvider → attachInfo、attachInfo 调用 Provider.onCreate。因此普通冷启动进程的常见调用顺序是:
Application 实例创建/attach
→ ContentProvider.onCreate()(如果绑定期需要创建 Provider)
→ Application.onCreate()
→ 后续具体 Activity.onCreate() / Service.onCreate() / Receiver.onReceive()(取决于触发原因)
注意,Provider.onCreate() 先于 Application.onCreate(),不代表 Provider 对象比 Application 对象更早创建:此时 Application 对象及其 Context 已经准备好,只是 Application.onCreate() 尚未执行。如果进程早已运行,系统也可能通过 scheduleInstallProvider() 通知该进程按需创建并初始化 Provider,无须重新执行 bindApplication。
六、BroadcastReceiver:清单接收器与动态注册接收器
广播投递也可能独立触发目标应用进程启动,不需要先启动 Activity 或 Service。当广播获准投递给清单声明的接收器、而目标进程尚未运行时,BroadcastQueueImpl.scheduleReceiverColdLocked() 会构造广播类型的 HostingRecord,并请求启动该进程:
// BroadcastQueueImpl.scheduleReceiverColdLocked(),节选
final HostingRecord hostingRecord = new HostingRecord(HostingRecord.HOSTING_TYPE_BROADCAST,
component, r.intent.getAction(), r.getHostingRecordTriggerType(), runInPccSandbox,
r.callingUid, r.callerApp != null ? r.callerApp.processName : null);
// ……
queue.app = mService.startProcessLocked(queue.processName, info, true, intentFlags,
hostingRecord, zygotePolicyFlags, allowWhileBooting, false);
源码:BroadcastQueueImpl:冷进程广播投递。动态注册的 Receiver 则依赖已有的注册进程:该进程消失后,旧注册不能再用来冷启动新进程。此外,广播还受投递规则和权限限制,不能理解成「任何广播都能拉起应用」。
进程可用后,队列通过 thread.scheduleReceiver(...) 调度清单接收器;客户端发 H.RECEIVER,handleReceiver() 实例化接收器并调用 onReceive():
// ActivityThread.handleReceiver(),节选
app = packageInfo.makeApplicationInner(false, mInstrumentation);
// ……准备 Context、Intent、ClassLoader……
receiver = packageInfo.getAppFactory()
.instantiateReceiver(cl, data.info.name, data.intent);
// ……
receiver.onReceive(context.getReceiverRestrictedContext(),
data.intent);
源码:服务端投递清单接收器、客户端 scheduleReceiver、handleReceiver / onReceive。对于进程仍在运行的动态注册 Receiver,系统通过 scheduleRegisteredReceiver() 和已有的 LoadedApk.ReceiverDispatcher 分发广播,最终也调用 onReceive();它不走上述按清单类名新建接收器实例的路径。源码:动态注册的分发入口、ReceiverDispatcher 调用 onReceive。Receiver 没有与 Activity/Service 对应的 onCreate();其业务入口是 onReceive()。
七、换个入口:不一定由 Activity 首先唤醒进程
前面分别介绍了四类组件的调度。下面用四个独立场景对照,均假设目标进程尚未运行,且相应请求获准执行:
- 打开界面:用户从桌面打开
MainActivity。ATMS 发现目标进程不可用时,先请求创建进程;新进程进入ActivityThread.main(),向 AMS 报到,并在主线程完成应用绑定、处理 Activity 启动事务。发起打开请求,不等于界面已经创建或完成绘制。 - 请求 Service:其他应用调用
startService(),或使用带BIND_AUTO_CREATE标志的bindService()。ActiveServices可以先拉起目标进程,再安排应用侧创建 Service,并按请求调度onStartCommand()或绑定回调;全程不需要先打开MainActivity。 - 访问 Provider:其他应用请求目标应用的 Provider。若目标进程不存在,AMS 可以为这次访问启动进程,并在应用绑定期间创建并初始化 Provider。此时 Provider 的
onCreate()可能先于Application.onCreate(),即使没有任何 Activity 启动请求。 - 投递清单广播:满足投递条件时,广播队列可以为清单声明的 Receiver 启动目标进程,进程就绪后再安排
onReceive()。动态注册不同:旧进程消失后,旧注册不能成为新的冷启动入口。
这四个场景彼此独立,并没有「先启动 Activity,再启动其他组件」的固定顺序。如果 MainActivity 此后调用 startActivity() 打开 DetailActivity,那也是应用新发起的一笔请求。
小结
读启动流程时,先确认目标组件所在进程是否可用,再追踪这次请求对应的组件调度。新进程进入 ActivityThread.main() 只说明进程已启动,不能据此认定组件已创建;Provider 还可能在应用绑定期间、Application.onCreate() 之前执行自己的 onCreate()。
参考源码
以下链接固定到同一份 AOSP frameworks/base 提交,便于对照版本差异,不使用机器上的源码路径: