Handler 消息机制面试知识点

整理自模拟面试，覆盖 Handler / Looper / MessageQueue / Message、源码链路、内存泄漏、主线程模型

1. Handler 机制是什么

一句话：Handler 机制本质上是 Android 的线程消息循环模型，用来把任务投递到指定线程顺序执行，最常见的是把子线程结果切回主线程更新 UI。

四个核心角色

Message：消息载体，包含 what / obj / arg1 / arg2
MessageQueue：消息存储结构，保存未来要执行的消息
Looper：消息循环器，不断从 MessageQueue 取消息
Handler：消息发送者和处理者，负责入队和回调处理

最常见用途

子线程切回主线程更新 UI
延迟任务：postDelayed() / sendMessageDelayed()
串行执行线程内任务
作为很多系统组件的底层调度基础

2. `Looper / MessageQueue / Handler` 三者关系

一句话：Looper 负责循环取消息，MessageQueue 负责存消息，Handler 负责发消息和处理消息，三者一起构成一个线程的任务调度模型。

持有关系

一个线程通常只有一个 Looper
一个 Looper 内部持有一个 MessageQueue
一个线程里可以有多个 Handler
多个 Handler 可以共享同一个 Looper 和 MessageQueue

工作流程

Looper.prepare() 给线程创建 Looper
Looper 创建时顺带创建 MessageQueue
Handler 创建时绑定当前线程的 Looper 和 MessageQueue
Handler 通过 sendMessage() / post() 把消息放进 MessageQueue
Looper.loop() 不断从队列中取消息
取到消息后分发给对应的 Handler

面试速记

Handler：投递和处理
MessageQueue：存储
Looper：轮询和分发

3. 从源码看 Handler 机制主链路

1. `Looper.prepare()`

源码核心点：
- 通过 ThreadLocal 把 Looper 绑定到当前线程
- 同时创建当前线程对应的 MessageQueue
- 一个线程只能调用一次，否则直接抛异常

关键源码关键词：
- ThreadLocal<Looper> sThreadLocal
- sThreadLocal.set(new Looper(...))
- Only one Looper may be created per thread

2. `Handler` 构造方法

源码核心点：
- Handler 创建时会调用 Looper.myLooper()
- 如果当前线程没有 Looper，会抛出经典异常
- 同时保存 mLooper 和 mQueue

关键源码关键词：
- mLooper = Looper.myLooper()
- mQueue = mLooper.mQueue
- Can't create handler inside thread that has not called Looper.prepare()

3. 发送消息

无论是 sendMessage() 还是 post()，最终都会走到入队逻辑。

源码核心点：
- sendMessageAtTime()
- enqueueMessage()
- 入队前会执行 msg.target = this

这里的意义是：
- 消息先记住“是谁发的”
- 之后 Looper 取出消息时，才能再准确分发回这个 Handler

4. 消息入队

MessageQueue.enqueueMessage() 会按 msg.when 把消息插入到合适位置，而不是简单尾插。

这说明：
- MessageQueue 支持延迟消息
- 底层更像按时间排序的有序链表，而不是普通 FIFO 队列

5. `Looper.loop()`

这是消息循环的核心源码。

关键逻辑：
- for (;;) { } 死循环
- queue.next() 取下一条消息
- msg.target.dispatchMessage(msg) 分发消息

这里能说明两件事：
- 真正不断取消息的是 Looper
- 最终处理消息的是消息里记录的那个 Handler

6. `dispatchMessage()`

源码里消息分发优先级是：
1. msg.callback != null，先执行 Runnable
2. 否则执行 Handler.Callback
3. 最后才走 handleMessage()

所以：
- post(Runnable) 本质也是发消息
- 只是把 Runnable 塞进了 Message.callback

4. 主线程为什么天生就能用 Handler

一句话：因为系统在应用启动时已经为主线程创建好了 Looper 并启动了消息循环。

源码入口

ActivityThread.main()
Looper.prepareMainLooper()
Looper.loop()

结论

主线程不是我们手动调用 prepare()
系统启动 App 时就已经把这套机制准备好了
所以我们在主线程里可以直接 new Handler()

5. 为什么子线程直接创建 Handler 会报错

原因：子线程默认没有 Looper。

典型异常

Can't create handler inside thread that has not called Looper.prepare()

根本原因

Handler 构造时会拿当前线程的 Looper
子线程默认没有执行 Looper.prepare()
没有 Looper，自然也就没有 MessageQueue

正确理解

不是 Handler 只能在主线程用
而是 Handler 只能在“已经准备好 Looper 的线程”里用

6. `post()` 和 `sendMessage()` 的区别

相同点

本质都是往 MessageQueue 里塞消息
最终都要经过 Looper.loop() 分发

不同点

方法	更适合的场景	底层表现
`post(Runnable)`	直接投递一段任务逻辑	把 `Runnable` 放到 `Message.callback`
`sendMessage(Message)`	传递结构化消息、根据 `what` 分发逻辑	正常使用 `Message.what / obj` 等字段

面试说法

简单任务优先 post
同类消息很多、需要分类处理时更适合 sendMessage

7. `MessageQueue` 为什么更像单链表

一句话：MessageQueue 名字叫队列，但从源码实现看，本质是按执行时间排序的单链表。

源码依据

MessageQueue 里有头节点：Message mMessages
Message 里有指针：Message next

为什么不是普通 FIFO 队列

Android 消息不仅要先进先出
还要支持 postDelayed()、sendMessageDelayed()
所以入队时需要根据 when 找插入位置

为什么链表适合

头部取消息成本低
按时间插入实现简单
Message 本身自带 next，便于对象池复用

注意

它功能语义上是“消息队列”
但底层结构更准确地说是“按时间排序的单链表”

8. 为什么 `Looper.loop()` 死循环不会一直占满 CPU

一句话：因为没有消息时，线程会阻塞等待，而不是空转。

关键点

Looper.loop() 虽然是 for (;;)
但真正取消息时调用的是 MessageQueue.next()
next() 在没有可执行消息时会进入阻塞等待

底层机制

Java 层负责消息调度
Native 层通过 nativePollOnce(...) 等机制阻塞和唤醒线程

结论

死循环不等于忙等
没有消息时线程会睡眠
所以不会天然导致 CPU 飙高

9. Handler 内存泄漏的原因

一句话：如果 Handler 是 Activity 的非静态内部类，而消息又在队列里延迟存在，就可能通过引用链把 Activity 持有住。

典型引用链

MessageQueue
-> Message
-> Handler
-> Activity

为什么会这样

Message.target 会指向 Handler
非静态内部类 Handler 会隐式持有外部 Activity
如果页面销毁了，但延迟消息还没执行完，就可能泄漏

常见解决方案

使用静态内部类 Handler
通过 WeakReference<Activity> 持有页面
在 onDestroy() 中调用 removeCallbacksAndMessages(null)

10. HandlerThread 是什么

一句话：HandlerThread 就是系统帮你封装好的“带 Looper 的子线程”。

作用

省去手动 Looper.prepare() / Looper.loop()
启动后可以直接拿它的 Looper 创建 Handler
适合串行后台任务、消息驱动型线程

常见用法

val handlerThread = HandlerThread("worker")
handlerThread.start()
val handler = Handler(handlerThread.looper)
handler.post {
    // 串行后台任务
}

适用场景

顺序执行后台任务
线程内事件循环
老代码或系统组件消息驱动场景

11. 高频追问

一个线程可以有几个 `Looper`

只能有一个
源码通过 ThreadLocal 限制了一个线程只能绑定一个 Looper

一个线程可以有几个 `Handler`

可以有多个
只要它们绑定的是同一个 Looper，就共享同一个 MessageQueue

为什么主线程能更新 UI

因为主线程已经初始化好了 Looper + MessageQueue
UI 的输入、动画、布局、绘制都依赖这套主线程消息循环模型

`post(Runnable)` 和重写 `handleMessage()` 谁先执行

如果消息里有 callback，优先执行 Runnable
然后才是 Handler.Callback
最后才是 handleMessage()

12. 一句话速记

知识点	速记
Handler 机制	本质是线程内消息循环和任务调度模型
三者关系	`Looper` 取消息，`MessageQueue` 存消息，`Handler` 发消息和处理消息
主线程 Handler	`ActivityThread.main()` 里系统提前准备好了主线程 `Looper`
子线程报错	默认没 `Looper`，`new Handler()` 会直接异常
`MessageQueue` 结构	语义上是队列，实现上更像按时间排序的单链表
死循环不空转	没消息时 `next()` 会阻塞等待
内存泄漏	延迟消息 + 内部类 `Handler` 可能把 Activity 持有住

Handler 消息机制 面试知识点