Android Handler 机制全解：从源码看懂消息循环

// frameworks/base/core/java/android/app/ActivityThread.java（简化）
public static void main(String[] args) {
    Looper.prepareMainLooper();          // ① 创建主线程 Looper
    ActivityThread thread = new ActivityThread();
    thread.attach(false, startSeq);      // ② 绑定 Application、AMS 等
    if (thread.mInstrumentation != null) {
        thread.mInstrumentation.callApplicationOnCreate(...);
    }
    Looper.loop();                       // ③ 进入消息循环，永不返回（正常情况）
    throw new RuntimeException("Main thread loop unexpectedly exited");
}

// frameworks/base/core/java/android/os/Looper.java（简化）
public static void prepareMainLooper() {
    prepare(false);                      // allowQuit = false，主 Looper 不可 quit
    synchronized (Looper.class) {
        if (sMainLooper != null) {
            throw new IllegalStateException("The main Looper has already been prepared.");
        }
        sMainLooper = myLooper();
    }
}
 
public static void prepare() {
    prepare(true);                       // 子线程 Looper 允许 quit
}
 
private static void prepare(boolean allowQuit) {
    if (sThreadLocal.get() != null) {
        throw new RuntimeException("Only one Looper may be created per thread");
    }
    sThreadLocal.set(new Looper(allowQuit));
}

// Looper.java
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<>();
 
public static @Nullable Looper myLooper() {
    return sThreadLocal.get();
}

// Handler.java（简化）
public Handler(@Nullable Callback callback, boolean async) {
    // ...
    mLooper = Looper.myLooper();
    if (mLooper == null) {
        throw new RuntimeException(
            "Can't create handler inside thread that has not called Looper.prepare()");
    }
    mQueue = mLooper.mQueue;
}

new Thread(() -> {
    Looper.prepare();                    // 创建 Looper 并放入 ThreadLocal
    Handler handler = new Handler();
    handler.post(() -> { /* 在此 Looper 线程执行 */ });
    Looper.loop();                       // 阻塞在此，开始消费消息
}).start();

// Looper.java（AOSP 简化，保留关键逻辑）
public static void loop() {
    final Looper me = myLooper();
    if (me == null) {
        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    final MessageQueue queue = me.mQueue;
 
    Binder.clearCallingIdentity();
    final long ident = Binder.clearCallingIdentity();
    final int thresholdOverride =
        me.mSlowDeliveryThresholdMs != INVALID_THRESHOLD
            ? (int) me.mSlowDeliveryThresholdMs : -1;
 
    for (;;) {
        Message msg = queue.next();      // 可能阻塞
        if (msg == null) {
            return;                      // quit 时退出
        }
 
        // 慢消息日志（调试用途）
        if (thresholdOverride >= 0) {
            // logIfSlow(...)
        }
 
        try {
            msg.target.dispatchMessage(msg);
        } finally {
            if (thresholdOverride >= 0) {
                // logIfSlow(...)
            }
        }
        Binder.clearCallingIdentity();
    }
}

// Message.java（核心字段）
public final class Message {
    public int what;
    public int arg1;
    public int arg2;
    public Object obj;
    Handler target;          // 由 Handler.enqueueMessage 赋值
    Runnable callback;       // post(Runnable) 时设置
    long when;               // 执行时间点（uptimeMillis）
 
    // 链表指针，MessageQueue 内部使用
    Message next;
    // 对象池
    private static Message sPool;
    private static int sPoolSize;
    // ...
}

public static Message obtain() {
    synchronized (sPoolSync) {
        if (sPool != null) {
            Message m = sPool;
            sPool = m.next;
            m.next = null;
            sPoolSize--;
            return m;
        }
    }
    return new Message();
}

// Handler.java
public final boolean post(@NonNull Runnable r) {
    return sendMessageDelayed(getPostMessage(r), 0);
}
 
private static Message getPostMessage(Runnable r) {
    Message m = Message.obtain();
    m.callback = r;
    return m;
}
 
public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {
    if (delayMillis < 0) {
        delayMillis = 0;
    }
    return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
 
public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) {
    // ...
    return enqueueMessage(msg, uptimeMillis);
}
 
private boolean enqueueMessage(Message msg, long when) {
    if (msg.target != null && msg.target.getLooper() != mLooper) {
        throw new IllegalArgumentException(
            "Message must be sent to the Handler's Looper!");
    }
    if (msg.target != null) {
        msg.target = this;
    }
    return mQueue.enqueueMessage(msg, when);
}

public void dispatchMessage(@NonNull Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);             // ① post(Runnable) 走这里
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;                  // ② Handler 构造时传入的 Callback
            }
        }
        handleMessage(msg);              // ③ 子类覆写 handleMessage
    }
}
 
private static void handleCallback(Message message) {
    message.callback.run();
}

// MessageQueue.java
Message mMessages;   // 队头

boolean enqueueMessage(Message msg, long when) {
    synchronized (this) {
        if (mQuitting) {
            msg.recycle();
            return false;
        }
 
        msg.when = when;
        Message p = mMessages;
        boolean needWake;
        if (p == null || when == 0 || when < p.when) {
            // 插到队头
            msg.next = p;
            mMessages = msg;
            needWake = mBlocked;         // 若正在 nativePollOnce 阻塞，需要唤醒
        } else {
            // 按 when 找到合适位置插入中间或尾部
            needWake = mBlocked && p.target == null && msg.isAsynchronous();
            Message prev;
            for (;;) {
                prev = p;
                p = p.next;
                if (p == null || when < p.when) {
                    break;
                }
            }
            msg.next = p;
            prev.next = msg;
        }
 
        if (needWake) {
            nativeWake(mPtr);            // 唤醒 epoll_wait
        }
    }
    return true;
}

@UnsupportedAppUsage
Message next() {
    final long ptr = mPtr;
    if (ptr == 0) {
        return null;
    }
 
    int pendingIdleHandlerCount = 0;
    int nextPollTimeoutMillis = 0;
    for (;;) {
        if (nextPollTimeoutMillis != 0) {
            Binder.flushPendingCommands();
        }
 
        nativePollOnce(ptr, nextPollTimeoutMillis);  // ★ 阻塞点
 
        synchronized (this) {
            final long now = SystemClock.uptimeMillis();
            Message prevMsg = null;
            Message msg = mMessages;
            // ... 同步屏障逻辑（见第八节）...
 
            if (msg != null) {
                if (now < msg.when) {
                    // 队头消息还没到时间，计算还要睡多久
                    nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                } else {
                    // 取走队头
                    mBlocked = false;
                    prevMsg = msg;
                    msg = msg.next;
                    prevMsg.next = null;
                    return prevMsg;
                }
            } else {
                nextPollTimeoutMillis = -1;          // 无消息，无限期等待
            }
 
            // IdleHandler 回调（队列空闲时）
            // ...
        }
    }
}

// frameworks/base/core/jni/android_os_MessageQueue.cpp（概念简化）
void NativeMessageQueue::pollOnce(int timeoutMillis) {
    // ...
    int eventCount = mEpollFd.modifyEvents(...);
    // epoll_wait 阻塞，直到：新消息入队(nativeWake)、定时器到期、fd 事件
    eventCount = mEpollFd.wait(timeoutMillis);
    // ...
}
 
void NativeMessageQueue::wake() {
    mWakeEventFd.write(1);   // 向 eventfd 写入，打断 epoll_wait
}

// Terminal 程序
while (true) {
    char* input = read();      // 阻塞等输入 → nativePollOnce()
    process(input);            // 处理 → dispatchMessage()
}

// Android Looper
for (;;) {
    Message msg = queue.next();          // 阻塞等消息
    msg.target.dispatchMessage(msg);     // 处理消息
}

// ✅ 正常：等待期间不占 CPU，新消息可唤醒
// Looper 在 nativePollOnce() 中睡眠
 
// ❌ 危险：dispatchMessage 执行太久
handler.post(() -> {
    Thread.sleep(5000);   // UI 无响应、ANR 风险
});

public static interface IdleHandler {
    boolean queueIdle();
}

// enqueueMessage 里判断异步消息是否需要唤醒
needWake = mBlocked && p.target == null && msg.isAsynchronous();

// ① 静态内部类 + 弱引用
private static class SafeHandler extends Handler {
    private final WeakReference<Activity> ref;
    SafeHandler(Activity activity) {
        super(Looper.getMainLooper());
        ref = new WeakReference<>(activity);
    }
    @Override
    public void handleMessage(Message msg) {
        Activity activity = ref.get();
        if (activity == null) return;
        // ...
    }
}
 
// ② onDestroy 清理
@Override
protected void onDestroy() {
    handler.removeCallbacksAndMessages(null);
    super.onDestroy();
}