为什么说ActivityThread是主线程？
这是一个非常经典的问题。要理解这一点，必须从Android 应用进程的启动机制和消息循环模型两个维度来拆解。
一、先说结论：ActivityThread 不是线程，但主线程的"灵魂"是它
ActivityThread的类定义是：
java
public final class ActivityThread { // 注意：它并没有 extends Thread }它本身不是java.lang.Thread的子类，但为什么说它是主线程的实际管理者？
因为：
应用进程的入口是
ActivityThread.main()方法main()方法中创建了主线程的 Looper 并启动消息循环主线程的所有工作（生命周期、UI 更新、事件处理）都是通过
ActivityThread内部的 Handler 分发的
所以，ActivityThread是主线程逻辑的载体，主线程的"肉体"是 Linux 的 UI 线程，"灵魂"是ActivityThread管理的消息循环和调度逻辑。
二、体现在哪里？逐层详解
1. 应用进程入口：main() 方法
当你点击 App 图标时，Zygote 进程 fork 出新的应用进程，新进程的入口不是Application.onCreate()，而是：
java
// android.app.ActivityThread // Android 框架约定：这条初始线程负责 UI 绘制、事件分发、生命周期回调，因此它被称为"主线程"（Main Thread）或"UI 线程" public static void main(String[] args) { // 1. 准备主线程的 Looper Looper.prepareMainLooper(); // 2. 创建 ActivityThread 实例 ActivityThread thread = new ActivityThread(); thread.attach(false, startSeq); // 3. 获取主线程的 Handler（即 H） if (sMainThreadHandler == null) { sMainThreadHandler = thread.getHandler(); } // 4. 开启消息循环，阻塞在这里，直到进程死亡 Looper.loop(); // 5. 如果 loop 退出，抛异常（主线程不允许退出） throw new RuntimeException("Main thread loop unexpectedly exited"); }关键体现：
Looper.prepareMainLooper()：为主线程创建唯一的Looper和MessageQueueLooper.loop()：主线程进入无限循环，不断从消息队列取消息执行这个
main()方法跑在应用进程的主线程上，所以ActivityThread是主线程的"入口管理者"
2. 主线程的消息分发中心：内部类 H
ActivityThread内部定义了一个名为H的 Handler（源码中真的叫H）：
java
// ActivityThread.java class H extends Handler { public static final int LAUNCH_ACTIVITY = 100; public static final int PAUSE_ACTIVITY = 101; public static final int STOP_ACTIVITY_SHOW = 103; public static final int RESUME_ACTIVITY = 107; public static final int DESTROY_ACTIVITY = 109; public static final int BIND_APPLICATION = 110; public static final int EXIT_APPLICATION = 111; public static final int RECEIVER = 113; public static final int CREATE_SERVICE = 114; public static final int SERVICE_ARGS = 115; public static final int STOP_SERVICE = 116; public static final int CONFIGURATION_CHANGED = 118; // ... 还有几十种消息类型 public void handleMessage(Message msg) { switch (msg.what) { case LAUNCH_ACTIVITY: { // 处理 Activity 创建 handleLaunchActivity((ActivityClientRecord) msg.obj); break; } case PAUSE_ACTIVITY: { // 处理 Activity 暂停 handlePauseActivity((ActivityClientRecord) msg.obj); break; } case RESUME_ACTIVITY: { // 处理 Activity 恢复 handleResumeActivity((ActivityClientRecord) msg.obj); break; } case DESTROY_ACTIVITY: { // 处理 Activity 销毁 handleDestroyActivity((ActivityClientRecord) msg.obj); break; } // ... } } }关键体现：
主线程的所有跨进程指令（来自 AMS）最终都变成
Message，被H接收H.handleMessage()在主线程执行，进而调用handleLaunchActivity、handleResumeActivity等这些
handleXxx方法内部会调用Instrumentation，最终触发Activity.onCreate()、onResume()等生命周期方法
所以你的onCreate()本质上是这样被执行的：
plain
AMS (系统进程) ↓ Binder 调用 ApplicationThread (应用进程 Binder 对象) ↓ 发送 Message H (主线程 Handler) ↓ handleMessage handleLaunchActivity() ↓ Instrumentation.callActivityOnCreate() ↓ Activity.performCreate() ↓ 你的 Activity.onCreate()3. 与系统服务通信的桥梁：ApplicationThread
ActivityThread内部持有ApplicationThread，它是一个Binder对象：
java
// ActivityThread.java private class ApplicationThread extends IApplicationThread.Stub { // AMS 通过 Binder 调用这些方法 public final void scheduleLaunchActivity(Intent intent, ...) { // 将参数封装成 ActivityClientRecord ActivityClientRecord r = new ActivityClientRecord(); r.intent = intent; // ... // 发送消息给 H，切换到主线程执行 sendMessage(H.LAUNCH_ACTIVITY, r); } public final void schedulePauseActivity(IBinder token, ...) { sendMessage(H.PAUSE_ACTIVITY, token); } public final void scheduleResumeActivity(IBinder token, ...) { sendMessage(H.RESUME_ACTIVITY, token); } public final void scheduleStopActivity(IBinder token, ...) { sendMessage(H.STOP_ACTIVITY_SHOW, token); } public final void scheduleDestroyActivity(IBinder token, ...) { sendMessage(H.DESTROY_ACTIVITY, token); } }关键体现：
ApplicationThread是Binder 服务端，运行在 Binder 线程池（非主线程）当 AMS 要启动/暂停/销毁 Activity 时，跨进程调用
ApplicationThread的方法ApplicationThread收到调用后，通过sendMessage()将任务抛回主线程的H处理这是典型的Binder 线程 → 主线程 的线程切换模型
4. 管理应用全局状态
ActivityThread持有一系列应用级别的核心对象：
java
public final class ActivityThread { // 当前应用的 Application 对象 Application mInitialApplication; // 当前应用的所有 Activity 记录 final ArrayMap<IBinder, ActivityClientRecord> mActivities = new ArrayMap<>(); // 当前应用的所有 Service 记录 final ArrayMap<IBinder, Service> mServices = new ArrayMap<>(); // 当前应用的 ResourcesManager final ResourcesManager mResourcesManager; // 当前应用的 LoadedApk（包含 APK 信息、ClassLoader 等） final ArrayMap<String, LoadedApk> mPackages = new ArrayMap<>(); // 主线程 Handler final H mH = new H(); }关键体现：
它管理着整个应用的 Activity、Service、Application 实例
它负责加载 APK 资源（通过
LoadedApk和ResourcesManager）它是单例的（通过
sCurrentActivityThread静态变量持有）
5. 创建并绑定 Application
在ActivityThread.attach()中：
java
private void attach(boolean system, long startSeq) { // 获取 AMS 的代理 final IActivityManager mgr = ActivityManager.getService(); try { // 将 ApplicationThread 注册到 AMS mgr.attachApplication(mAppThread, startSeq); } catch (RemoteException ex) { throw ex.rethrowFromSystemServer(); } }AMS 收到attachApplication后，会反向调用ApplicationThread.bindApplication()，最终触发：
java
// ActivityThread.java private void handleBindApplication(AppBindData data) { // 1. 创建 LoadedApk // 2. 创建 Instrumentation // 3. 创建 Application Application app = data.info.makeApplication(...); // 4. 调用 Application.onCreate() mInstrumentation.callApplicationOnCreate(app); }关键体现：
Application.onCreate()不是凭空调用的，是由ActivityThread在handleBindApplication中触发的这再次证明
ActivityThread是应用组件生命周期的总调度中心
三、总结：为什么说 ActivityThread 是主线程的管理者？
表格
| 维度 | 具体体现 |
|---|---|
| 进程入口 | ActivityThread.main()是应用进程启动后的第一个 Java 方法，负责初始化主线程 Looper |
| 消息循环 | 主线程的Looper.loop()在main()中启动，ActivityThread掌控消息循环的生命周期 |
| 任务分发 | 内部类H（Handler）接收所有系统指令（LAUNCH、PAUSE、RESUME、DESTROY），在主线程分发执行 |
| 跨进程桥接 | ApplicationThread（Binder）接收 AMS 指令，通过H切换到主线程，实现Binder 线程 → 主线程的调度 |
| 组件管理 | 管理 Application、所有 Activity/Service 实例、Resources、LoadedApk 等全局状态 |
| 生命周期触发 | handleLaunchActivity、handleResumeActivity等方法最终调用Instrumentation，触发你的onCreate、onResume |
四、一张图看懂关系
plain
┌─────────────────────────────────────────────────────────────┐ │ 系统进程 (system_server) │ │ ActivityManagerService (AMS) │ └──────────────────────┬──────────────────────────────────────┘ │ 跨进程 Binder 调用 ▼ ┌─────────────────────────────────────────────────────────────┐ │ 应用进程 (App Process) │ │ │ │ ┌─────────────────┐ ┌─────────────────────────────┐ │ │ │ ApplicationThread │◄──│ Binder 线程池（非主线程） │ │ │ │ (Binder 服务端) │ └─────────────────────────────┘ │ │ └────────┬────────┘ │ │ │ sendMessage(H.XXX) │ │ ▼ │ │ ┌─────────────────┐ ┌─────────────────────────────┐ │ │ │ H │────►│ 主线程 MessageQueue │ │ │ │ (Handler) │ │ (Looper.loop() 循环) │ │ │ └────────┬────────┘ └─────────────────────────────┘ │ │ │ │ │ ▼ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ handleLaunchActivity() │ │ │ │ handleResumeActivity() │ │ │ │ handlePauseActivity() │ │ │ │ handleDestroyActivity() │ │ │ └────────┬────────────────────────────────────────────┘ │ │ │ │ │ ▼ │ │ ┌─────────────────┐ ┌─────────────────────────────┐ │ │ │ Instrumentation │────►│ Activity.onCreate() │ │ │ │ │ │ Activity.onResume() │ │ │ └─────────────────┘ └─────────────────────────────┘ │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ ActivityThread (单例) │ │ │ │ • 持有 mH (Handler) │ │ │ │ • 持有 mActivities (Activity 集合) │ │ │ │ • 持有 mInitialApplication │ │ │ │ • 持有 mAppThread (ApplicationThread) │ │ │ └─────────────────────────────────────────────────────┘ │ └─────────────────────────────────────────────────────────────┘五、一句话总结
ActivityThread不是线程本身，但它是主线程的"大脑"：它占据了主线程的main()入口，启动了主线程的 Looper 循环，并通过内部 HandlerH统一接收和分发所有系统级指令（Activity 生命周期、Service 启动等），因此它是 Android 应用主线程的实际管理者。