Android Handler 机制完全解析：从源码到内存泄漏，一篇就够了

一、为什么需要 Handler？

Android 的主线程不允许执行耗时操作同时非主线程不能直接更新 UI。Handler 就是连接"后台线程"和"主线程"的桥梁：子线程完成任务后通过 Handler 把结果抛回主线程执行。按理说，

但这只是表象。Handler 的本质是 跨线程通信 + 任务调度——它依赖于 Looper + MessageQueue 构成的消息循环。

二、架构总览：四大组件

痛点提醒： 你在多次使用 handler.post 时是否发现某些 Activity 却一直在后台运行？往往是因为没有及时移除回调导致的内存泄漏。

一句话流程这方面，

三、Looper：消息循环的发动机

谁创建了主线程的 Looper？

MOST people know that main thread has a default Looper,but few look at ActivityThread.java's source:

// android/app/ActivityThread.java
public static void main {
// ...
// ① 为主线程创建 Looper 和 MessageQueue
Looper.prepareMainLooper;说起来，// ② 开始消息循环 —— 主线程就在这里"卡住"了
Looper.loop;说起来，// ③ loop 返回代表着程序退出。正常情况下永远不会执行到这里
throw new RuntimeException;}

Looper.prepare：ThreadLocal 的经典应用

The core of this is {ThreadLocal},which isolates each thread’s Looper instance.

// android/os/Looper.java
static final ThreadLocal sThreadLocal = new ThreadLocal;private static void prepare {
if!= null) {
throw new RuntimeException;}
sThreadLocal.set);}
public static void prepareMainLooper {
prepare;setMainLooper);}
...
public static @Nullable Looper myLooper {
return sThreadLocal.get;
}

• The sThreadLocal.set actually stores an Entry in current Thread’s internal map.
• This guarantees that each thread can retrieve its own looper via sThreadLocal.get.
• The main looper is stored additionally in a static field so it can be accessed from any thread.

. ThreadLocal 内部结构：一张图看懂

A simplified view of how ThreadLocal stores values per thread:

// Simplified illustration of Thread & ThreadLocalMap
┌───────────────────────┐
│ Thread object │
│ ┌───────────────────┐ │
│ │threadLocals │ │
│ └───────────────────┘ │
│ ┌───────────────┐ │
│ │ Entry table │ │
│ └───────────────┘ │
└───────────────────────┘
// Entry holds key & value
*The key being weak means if ThreadLocal itself is GC‑ed,its entry can be reclaimed while value stays alive — a classic leak source.*

Looger 构造方法：创建 MessageQueue 
// android/os/Looper.java
private Looper {
mQueue = new MessageQueue;mThread = Thread.currentThread;}


Looger.loop: 永不终止的 for 循环 
// android/os/Looper.java
public static void loop {
final Looper me = myLooper;if throw new RuntimeException;final MessageQueue queue = me.mQueue;for {
Message msg = queue.next;// may block on nativePollOnce
if return;msg.target.dispatchMessage;msg.recycleUnchecked;}
}


四、MessageQueue：消息的优先级队列 

enqueueMessage: 消息入队 
// android/os/MessageQueue.java
boolean enqueueMessage {
if throw new IllegalArgumentException;synchronized {
if { msg.recycle;return false;}
msg.markInUse;msg.when = when;// Insert at head or sorted by 'when'
...
if nativeWake;}
return true;}




{@link Message} are linked in ascending order by {@link when} timestamp.

If insertion affects head while loop is blocked,{@link nativeWake} will resume it.

{@link when==0} means immediate execution and always goes to head.

{Important!} The message holds a strong reference to its target {@link Handler}: msg.target=this during send. This is a typical leak point.

{Important!} If you forget to call {@link #removeCallbacksAndMessages} before destroying a component that owns a handler,all pending messages keep that component alive until processed or cancelled.
.


痛点
如果你在 Activity 或 Fragment 中直接创建一个非静态内部类 new Handler 并使用 postDelayed当页面销毁后这些 Runnable 会被保留在全局队列里从而持有外部类实例导致内存泄漏。



…etc，按理说，