一、核心类关系与线程绑定（ThreadLocal 的核心作用）

1. Looper 与 ThreadLocal 的绑定

每个线程的 Looper 实例通过 ThreadLocal<Looper> sThreadLocal 存储，确保线程隔离：

public final class Looper {// 线程本地存储，每个线程独有一个 Looperstatic final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();// 主线程 Looper（ActivityThread 中创建）static Looper sMainLooper; final MessageQueue mQueue; // 关联的消息队列final Thread mThread; // 绑定的线程private Looper(boolean quitAllowed) {mQueue = new MessageQueue(quitAllowed);mThread = Thread.currentThread(); // 记录当前线程}// 线程首次调用，创建 Looper 并存储到 ThreadLocalpublic static void prepare() {prepare(false); // quitAllowed 默认 false（主线程不允许退出）}private static void prepare(boolean quitAllowed) {if (sThreadLocal.get() != null) { // 禁止重复创建throw new RuntimeException("Only one Looper may be created per thread");}sThreadLocal.set(new Looper(quitAllowed)); // 存入当前线程的 Looper}// 获取当前线程的 Looperpublic static @Nullable Looper myLooper() {return sThreadLocal.get();}
}

• 主线程：Android 框架在 ActivityThread.main() 中自动调用 Looper.prepareMainLooper() 和 Looper.loop()，无需手动处理。
• 子线程：必须手动调用 Looper.prepare()（创建 Looper 和 MessageQueue）和 Looper.loop()（启动消息循环），否则 Handler 无可用 Looper 会报错。

2. Handler 的构造与 Looper 关联

Handler 实例必须与一个 Looper 绑定，默认使用当前线程的 Looper（通过 Looper.myLooper() 获取）：

public class Handler {final Looper mLooper; // 关联的 Looperfinal MessageQueue mQueue; // Looper 的消息队列final Callback mCallback; // 消息回调public Handler() {this(null, false);}public Handler(@Nullable Callback callback, boolean async) {if (FIND_POTENTIAL_LEAKS) {final Class<? extends Handler> klass = getClass();if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&(klass.getModifiers() & Modifier.STATIC) == 0) {Log.w(TAG, "The following Handler class should be static or leaks might occur: "+ klass.getCanonicalName());}}mLooper = Looper.myLooper(); // 获取当前线程的 Looper（必须已 prepare）if (mLooper == null) {throw new RuntimeException("Can't create handler inside thread " + Thread.currentThread()+ " that has not called Looper.prepare()");}mQueue = mLooper.mQueue; // 关联消息队列mCallback = callback;mAsynchronous = async;}
}

• 若子线程未调用 Looper.prepare()，创建 Handler 时会抛出 RuntimeException，这就是子线程必须先准备 Looper 的原因。

二、消息发送：从 Handler 到 MessageQueue 的入队

1. Message 的创建与重用（消息池机制）

Message 优先从消息池获取，避免频繁 GC：

public final class Message implements Parcelable {// 消息池头节点（静态，所有线程共享）private static Message sPool;// 消息池大小（最大 50 个）private static int sPoolSize = 0;// 下一个可用消息（形成单链表）@UnsupportedAppUsageMessage next;// 从消息池获取消息public static Message obtain() {synchronized (sPoolSync) { // 线程安全if (sPool != null) {Message m = sPool;sPool = m.next; // 取出头节点m.next = null; // 断开引用m.flags = 0; // 重置标志位sPoolSize--;return m;}}return new Message(); // 池空时新建}// 回收消息到池中（处理完后调用）void recycleUnchecked() {if (isInUse()) { // 确保未被使用if (gCheckRecycle) {throw new IllegalStateException("This message cannot be recycled because it "+ "is still in use.");}return;}recycle();}private void recycle() {if (mRecycled) { // 已回收过则不再处理return;}mRecycled = true;if (sPoolSize < MAX_POOL_SIZE) { // 最大 50 个next = sPool;sPool = this;sPoolSize++;}}
}

• 优势：减少对象创建开销，提升性能，尤其适合高频发送消息的场景。

2. MessageQueue 的入队逻辑（enqueueMessage）

消息按 msg.when（执行时间）排序插入，形成一个 非严格 FIFO 的有序单链表：

boolean enqueueMessage(Message msg, long when) {msg.target = this; // target 指向发送消息的 Handlermsg.workSourceUid = ThreadLocalWorkSource.getUid();synchronized (this) { // 加锁保证线程安全if (mQuitting) { // 队列已退出，回收消息IllegalStateException e = new IllegalStateException(msg.target + " sending message to a Handler on a dead thread");Log.w(TAG, e.getMessage(), e);msg.recycle();return false;}msg.markInUse();msg.when = when;Message p = mMessages; // 当前头节点boolean needWake;if (p == null || when == 0 || when < p.when) { // 新消息时间更早，插入头部msg.next = p;mMessages = msg;needWake = mBlocked; // 当前队列是否阻塞，决定是否唤醒} else { // 找到合适位置插入（按 when 升序）needWake = mBlocked && p.target == null && msg.isAsynchronous();Message prev;for (;;) { // 遍历链表找到插入点prev = p;p = p.next;if (p == null || when < p.when) {break;}if (needWake && p.isAsynchronous()) {needWake = false;}}msg.next = p;prev.next = msg;}// 若队列阻塞且需要唤醒（如 Looper.loop() 在等待），通过 native 方法唤醒if (needWake) {nativeWake(mPtr);}}return true;
}

• 关键点：
  • synchronized (this) 确保多线程安全，不同线程的 Handler 发送消息到同一 MessageQueue 时不会冲突。
  • 消息按 when 排序，而非严格的 FIFO，支持延迟消息（如 postDelayed）。
  • 异步消息（msg.setAsynchronous(true)）可打断同步消息的等待，优先处理。

三、消息循环：Looper.loop () 的无限循环

1. loop () 方法核心逻辑

public static void loop() {final Looper me = myLooper(); // 获取当前线程的 Looperif (me == null) {throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");}final MessageQueue queue = me.mQueue; // 关联的消息队列// 确保主线程 Looper 不会被 GC 回收（Binder 机制相关）Binder.clearCallingIdentity();final long ident = Binder.clearCallingIdentity();for (;;) { // 无限循环，直到队列退出Message msg = queue.next(); // 取出消息（可能阻塞）if (msg == null) { // 队列退出（msg.next == null）return; // 退出循环}// 处理消息：通过 msg.target（Handler）分发msg.target.dispatchMessage(msg);// 回收消息到池中（非必须，系统自动处理）msg.recycleUnchecked();}
}

2. MessageQueue.next () 的阻塞与唤醒

next() 是消息循环的核心，通过 native 层实现阻塞等待：

Message next() {final long ptr = mPtr; // 指向 native 层的 MessageQueue 实例int pendingIdleHandlerCount = -1; // 首次调用时初始化为 -1int nextPollTimeoutMillis = 0;for (;;) {if (nextPollTimeoutMillis != 0) {Binder.flushPendingCommands();}// native 层阻塞等待消息，直到有消息或被唤醒nativePollOnce(ptr, nextPollTimeoutMillis);synchronized (this) {// 检查是否有消息待处理final long now = SystemClock.uptimeMillis();Message prevMsg = null;Message msg = mMessages;if (msg != null && msg.when > now) { // 消息未到执行时间，计算延迟nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);} else { // 有可执行的消息，取出头节点msg = mMessages;mMessages = msg.next;msg.next = null;if (DEBUG) Log.v(TAG, "Returning message: " + msg);nextPollTimeoutMillis = -1; // 下次立即 poll}if (msg != null) { // 有消息，返回给 Looperreturn msg;}// 无消息，检查是否退出mQuitting = true;return null;}}
}

• 阻塞原理：通过 nativePollOnce 进入内核等待，当消息入队时（enqueueMessage 中调用 nativeWake）被唤醒。
• 退出条件：调用 Looper.quit() 或 Looper.quitSafely() 时，mQuitting 设为 true，next() 返回 null，loop() 终止。

四、消息处理：Handler.dispatchMessage 的分发逻辑

消息最终由发送它的 Handler 处理，分发流程如下：

public void dispatchMessage(Message msg) {if (msg.callback != null) { // 优先处理 Message 的 Runnable（post(Runnable)）handleCallback(msg);} else if (mCallback != null) { // 其次处理 Handler 的 Callbackif (mCallback.handleMessage(msg)) {return;}}handleMessage(msg); // 最后调用用户重写的 handleMessage()
}private static void handleCallback(Message message) {message.callback.run(); // 执行 post(Runnable) 传入的 Runnable
}

• 三种处理方式：
  1. Message 自带的 Runnable：通过 post(Runnable) 发送的消息，直接执行 Runnable.run()。
  2. Handler 的 Callback：通过构造函数传入的 Callback，优先级高于 handleMessage。
  3. 用户重写的 handleMessage：最常用的消息处理逻辑。

五、子线程使用 Handler 的完整流程（源码级示例）

// 子线程类
class WorkerThread extends Thread {private Handler mHandler;private Looper mLooper;// 获取 Handler（供外部发送消息）public Handler getHandler() {return mHandler;}@Overridepublic void run() {// 1. 准备 Looper（创建 Looper 和 MessageQueue）Looper.prepare();synchronized (this) {mLooper = Looper.myLooper(); // 保存当前线程的 LoopermHandler = new Handler() { // 创建 Handler 关联当前 Looper@Overridepublic void handleMessage(Message msg) {// 处理消息（子线程中执行）processMessage(msg);if (msg.what == MSG_QUIT) { // 退出消息mLooper.quit(); // 停止消息循环}}};notify(); // 通知主线程 Handler 已准备好}// 2. 启动消息循环Looper.loop();}
}// 主线程使用子线程 Handler
public class MainActivity extends AppCompatActivity {private WorkerThread mWorkerThread;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);mWorkerThread = new WorkerThread();mWorkerThread.start();synchronized (mWorkerThread) {try {mWorkerThread.wait(); // 等待子线程准备好 Handler} catch (InterruptedException e) {e.printStackTrace();}}// 向子线程发送消息Message msg = Message.obtain();msg.what = WorkerThread.MSG_WORK;mWorkerThread.getHandler().sendMessage(msg);// 发送退出消息mWorkerThread.getHandler().sendMessage(Message.obtain(null, WorkerThread.MSG_QUIT));}
}

• 关键步骤：
  1. 子线程中调用 Looper.prepare() 创建 Looper 和 MessageQueue。
  2. 创建 Handler 时自动关联当前 Looper（因在 prepare() 之后调用）。
  3. 调用 Looper.loop() 启动消息循环，处理外部发送的消息。
  4. 通过 Looper.quit() 终止循环，避免子线程阻塞。

六、常见问题源码级解析

1. 为什么主线程可以直接创建 Handler？

• 主线程（ActivityThread 所在线程）在启动时，框架自动调用了：

  public static void main(String[] args) {// ...Looper.prepareMainLooper(); // 准备主线程 LooperActivityThread thread = new ActivityThread();thread.attach(false, startSeq);Looper.loop(); // 启动主线程消息循环
  }
  

  
  因此主线程的 Looper 已存在，无需手动调用 prepare()。

2. MessageQueue 真的是 “队列” 吗？

• 从数据结构看，它是一个 单链表，而非传统的 FIFO 队列。消息按 msg.when 排序插入，保证按时间顺序执行，支持延迟消息。

3. postDelayed 不准时的根本原因？

• postDelayed 计算延迟的基准时间是 SystemClock.uptimeMillis()（系统启动后非休眠时间），若设备休眠，休眠时间不计入延迟，导致实际执行时间晚于预期。
• 此外，消息需等待前面的消息处理完成，若主线程被阻塞（如耗时操作），延迟消息会被阻塞。

4. 多线程发送消息到同一 MessageQueue 为何线程安全？

• MessageQueue.enqueueMessage 使用 synchronized (this) 加锁，确保同一时间只有一个线程操作队列，避免并发问题。

七、Handler 机制的设计精髓

1. 线程隔离：通过 ThreadLocal 保证每个线程独有 Looper 和 MessageQueue，避免资源竞争。
2. 消息池：重用 Message 对象，减少内存分配和 GC 压力，提升性能。
3. 有序调度：按时间排序的消息链表，支持延迟和异步消息，灵活控制执行顺序。
4. 阻塞与唤醒：通过 native 层实现高效的等待与唤醒，避免 CPU 空转。

总结

     Handler 机制的核心是通过 Looper（消息循环）、MessageQueue（有序消息链表）、Handler（消息收发器） 的协作，实现线程间的安全通信。源码中大量使用 ThreadLocal、synchronized、单链表等技术，确保线程隔离、数据安全和性能优化。深入理解这些细节，能帮助开发者更好地处理线程通信、避免内存泄漏（如非静态内部类 Handler 导致的 Activity 泄漏），并在复杂场景中灵活运用 Handler 机制。