为什么说ActivityThread是主线程？

这是一个非常经典的问题。要理解这一点，必须从 Android 应用进程的启动机制 和 消息循环模型 两个维度来拆解。

---

一、先说结论：ActivityThread 不是线程，但主线程的"灵魂"是它

ActivityThread 的类定义是：

java

public final class ActivityThread {
    // 注意：它并没有 extends Thread
}

它本身不是 java.lang.Thread 的子类，但为什么说它是主线程的实际管理者？

因为：

1. 应用进程的入口 是 ActivityThread.main() 方法

2. main() 方法中创建了主线程的 Looper 并启动消息循环

3. 主线程的所有工作（生命周期、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 和 MessageQueue

• Looper.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 循环，并通过内部 Handler H 统一接收和分发所有系统级指令（Activity 生命周期、Service 启动等），因此它是 Android 应用主线程的实际管理者。