Android 消息机制剖析:从 Handler 投递到 Looper 循环的全链路

从一段熟悉的通信代码说起

Handler 的使用,大家应该都很熟悉了,比如我们经常用它来在子线程中更新 UI:

kotlin 复制代码
class MainActivity : AppCompatActivity() {

    private lateinit var textView: TextView

    private val mMainHandler = Handler(Looper.getMainLooper()) { message ->
        if (message.obj != null) {
            // 主线程更新UI
            val newText = message.obj as? String ?: return@Handler false
            textView.text = newText
            return@Handler true
        }

        return@Handler false
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        textView = findViewById(R.id.textView)

        // 开启一个子线程
        thread {
            Thread.sleep(3000)
            // 投递消息
            val message = mMainHandler.obtainMessage(0, "3 seconds later")
            mMainHandler.sendMessage(message)
        }
    }
}

在上述代码中,我们就完成了一次线程间的通信,那它是怎么实现的呢?我们直接看 sendMessage 的源码(当然是有目的的阅读,不了解的代码会简单介绍一下)。

消息入队:MessageQueue 是如何排队的?

sendMessage 会调用 sendMessageDelayed,sendMessageDelayed 会调用 sendMessageAtTime:

java 复制代码
// Handler.java

public final boolean sendMessage(@NonNull Message msg) {
    return sendMessageDelayed(msg, 0);
}

public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {
    if (delayMillis < 0) {
        delayMillis = 0;
    }
    return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}

其中 sendMessageDelayed 计算出的是消息的计划执行时刻 (稍后会赋值给消息的 when 字段)。传入的延时为 0,表示计划执行时刻没有延时,需要被立即处理。

SystemClock.uptimeMillis() 获取的是系统开机后的时长,时长中不包括设备睡眠的时间(如屏幕关闭),同时与 System.currentTimeMillis() 不同,它不会受到用户手动修改系统时间的影响。

再进入 sendMessageAtTime:

java 复制代码
// Handler.java

public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) {
    MessageQueue queue = mQueue;
    if (queue == null) {
        RuntimeException e = new RuntimeException(
                this + " sendMessageAtTime() called with no mQueue");
        Log.w("Looper", e.getMessage(), e);
        return false;
    }
    return enqueueMessage(queue, msg, uptimeMillis);
}

这里出现了一个消息队列 mQueue,它是后续要说到的 Looper 中的队列。

java 复制代码
// Handler.java

// 入队一条消息
private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg, long uptimeMillis) {
    // 绑定目标 Handler
    msg.target = this;
    msg.workSourceUid = ThreadLocalWorkSource.getUid();

    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    onBeforeEnqueue(queue, msg, uptimeMillis); // 空实现
    return queue.enqueueMessage(msg, uptimeMillis);
}

关键在于 Handler 的绑定以及 enqueueMessage 入队操作。

ThreadLocalWorkSource.getUid() 记录了底层调用的 UID,用于耗电量统计等分析;Message.setAsynchronous(true) 的作用是将消息标记为异步消息,通常配合消息队列的同步屏障使用,用来优先处理 UI 绘制等高优先级任务。这些机制和主路径关系不大。

再进入 MessageQueue 中的 enqueueMessage,这里有一个分支实现,看 sUseDeliQueue 的注释得知 enqueueMessageLegacy 是旧版兼容实现,DeliQueue 性能会更好,但是我们就不看它了。

java 复制代码
// MessageQueue.java

boolean enqueueMessage(Message msg, long when) {
    if (msg.target == null) {
        throw new IllegalArgumentException("Message must have a target.");
    }

    if (sUseDeliQueue) {
        return enqueueMessageDeliQueue(msg, when);
    } else {
        return enqueueMessageLegacy(msg, when);
    }
}

直接看 enqueueMessageLegacy:

java 复制代码
private boolean enqueueMessageLegacy(Message msg, long when) {
    synchronized (this) {
        if (msg.isInUse()) {
            throw new IllegalStateException(msg + " This message is already in use.");
        }

        if (mQuitting) {
            logDeadThread(msg);
            return false;
        }

        // 标记消息正在使用
        msg.markInUse();
        msg.when = when;
        incAndTraceMessageCount(msg, when);

        Message p = mMessages;
        boolean needWake;
        // 队列为空,或需要插队到队首
        if (p == null || when == 0 || when < p.when) {
            msg.next = p;
            mMessages = msg;
            needWake = mBlocked;
            if (p == null) {
                // 更新最后消息的记录
                mLast = mMessages;
            }
        } else {
            ...
        }

        if (msg.isAsynchronous()) {
            mAsyncMessageCount++;
        }

        if (needWake) {
            nativeWake(mPtr);
        }
    }
    return true;
}

mMessages 代表的是一个链表头指针,首次入队时,mMessages == null,所以会将消息头插,mMessages 变为有一个节点的链表。

另外,如果 when == 0,也会将消息放到首位。系统 API 中的 sendMessageAtFrontOfQueue() 其实是通过传入 when = 0 来实现消息插队的。这也能看出,这个队列是严格按计划执行时刻(when)进行排序的。

现在一次消息投递就结束了,实际上就是将消息投递到 Looper 的 MessageQueue 消息队列中(只是由 Handler 持有),队列实际上是一个单链表。此外设置了一下消息的目标处理 Handler,以及消息的计划执行时刻。

如果你连续发送了三条消息:

kotlin 复制代码
mMainHandler.sendMessage(Message.obtain(mMainHandler, 0, "immediately"))
mMainHandler.sendMessageDelayed(
    Message.obtain(mMainHandler, 0, "3 seconds later"),
    3000
)
mMainHandler.sendMessageDelayed(
    Message.obtain(mMainHandler, 0, "1 seconds later"),
    1000
)

队列会是怎么样的呢?假设 SystemClock.uptimeMillis() 为 T,按我们之前的分析,应该是这样的吧:

csharp 复制代码
Message[0, "immediately", when = T + 0]  ==> Message[0, "1 seconds later", when = T + 1000]  ==> Message[0, "3 seconds later", when = T + 3000]

直接看 enqueueMessageLegacy 的 else 分支,第二条消息(when 为 T + 3000),由于执行时刻晚于前一条消息,会走到 when >= mLast.when 分支中,将消息放到链表尾部。

java 复制代码
if (when >= mLast.when) {
    needWake = needWake && mAsyncMessageCount == 0;
    // 消息尾插
    msg.next = null;
    mLast.next = msg;
    mLast = msg;
} else {
    Message prev;
    for (;;) {
        prev = p;
        p = p.next;
        // 已是尾巴 或 当前节点的时刻晚于要插入消息的时刻
        if (p == null || when < p.when) {
            break;
        }
        if (needWake && p.isAsynchronous()) {
            needWake = false;
        }
    }
    if (p == null) {
        mLast = msg;
    }
    // 插入消息
    msg.next = p;
    prev.next = msg;
}

而对于第三条消息(when 为 T + 1000),会进入 else 的 for 循环分支,逐个对比 when 的大小,找到合适的节点(它应该排在 T+3000 的消息前面),并将消息插入到该节点前面。看完发现三条消息的插入结果符合我们的预期,确实是按照绝对时间排序的。

另外,enqueueMessageLegacy 的最后有这么一段代码:当新消息被插到队首(队列原本为空,或新消息的执行时刻早于原队首)且当前线程正处于阻塞状态(mBlocked 为 true)时,needWake 会被标记为 true。此时会通过 nativeWake 唤醒处于阻塞状态的线程,这和后续要讲到的 Looper 取消息时的阻塞机制是对应的。

java 复制代码
if (needWake) {
    nativeWake(mPtr);
}

消息分发:Looper 的死循环与线程隔离

如果在子线程中直接获取 Looper 创建 Handler 并发送消息,会报异常。

kotlin 复制代码
thread {
    val looper = Looper.myLooper()!!
    val handler = Handler(looper) { message ->
        Log.d(
            "${Thread.currentThread().name} Handler",
            "Message received: Message(what=${message.what}, obj=${message.obj}!)"
        )
        true
    }
    handler.sendMessage(handler.obtainMessage(0, "Hi"))
}

我们传入了一个 Looper,但因为此时子线程的 Looper 还没被创建,会直接触发空指针异常。

所以我们需要先调用 Looper.prepare(),最后调用 Looper.loop():

kotlin 复制代码
thread {
    Looper.prepare()
    val looper = Looper.myLooper()!!
    val handler = Handler(looper) { message ->
        Log.d(
            "${Thread.currentThread().name} Handler",
            "Message received: Message(what=${message.what}, obj=${message.obj}!)"
        )
        true
    }
    handler.sendMessage(handler.obtainMessage(0, "Hi"))
    Looper.loop()
}

消息的处理流程正需要 Looper 的参与。

简易的 Handler 和 Looper 模型可以看我的这篇博客:Android 多线程:理解 Handler 与 Looper 机制。

那这两行代码干了什么?我们进去看看。首先是 prepare():

java 复制代码
// Looper.java

public static void prepare() {
    prepare(true);
}

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));
}
java 复制代码
// ThreadLocal.java

public void set(T value) {
    set(Thread.currentThread(), value);
    if (TRACE_VTHREAD_LOCALS) {
        dumpStackIfVirtualThread();
    }
}

private void set(Thread t, T value) {
    // 重点
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        map.set(this, value);
    } else {
        createMap(t, value);
    }
}

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

它实际上是创建了一个 Looper 对象,然后放在了当前线程内部的 threadLocals(ThreadLocal.ThreadLocalMap 类型) 中。

ThreadLocal 实现了数据的线程隔离,这保证了每个线程最多只能拥有一个唯一的 Looper 对象和一个对应的 MessageQueue,确保消息的分发不会在多线程间错乱。

java 复制代码
// Looper.java

private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed);
    mThread = Thread.currentThread();
}

创建 Looper 对象中,初始化了消息队列,以及记录创建时所在的线程。

之前调用的 Looper.myLooper(),就会从当前线程中的 threadLocals 拿刚刚放入的 Looper 对象。

java 复制代码
// Looper.java

public static @Nullable Looper myLooper() {
    return sThreadLocal.get();
}
java 复制代码
// ThreadLocal.java

public T get() {
    return get(Thread.currentThread());
}

private T get(Thread t) {
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T) e.value;
            return result;
        }
    }
    return setInitialValue(t);
}

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

总的来说,Looper.prepare() 是为了创建线程专属的 Looper 对象,初始化消息队列,为后续的循环做准备。

Looper.loop() 就是这个循环,它会获取当前的 Looper 对象,然后开启一个死循环,每次循环都会调用 loopOnce()。

java 复制代码
// Looper.java

public static void loop() {
    final Looper me = myLooper();
    if (me == null) {
        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    
    // ... 省略部分检查代码

    for (;;) {
        if (!loopOnce(me, ident, thresholdOverride)) {
            return;
        }
    }
}

loopOnce() 源码很长,所以做了一些省略:

java 复制代码
// Looper.java

private static boolean loopOnce(final Looper me, final long ident, final int thresholdOverride) {
    // 从 Looper 的队列中取消息
    Message msg = me.mQueue.next();
    if (msg == null) {
        // 队列已退出,结束轮询
        return false;
    }

    ...
    
    try {
        // 将消息分发给目标的 Handler
        msg.target.dispatchMessage(msg);
        
        ...
    } catch (Exception exception) {
        ...
    } finally {
        ...
    }
    
    ...
    
    // 回收 Message 对象
    msg.recycleUnchecked();

    return true;
}

既然 Looper.loop() 是一个死循环,为什么不会导致 CPU 占用率飙升?

这里的 me.mQueue.next() 不是简单地从队列中取一个值,如果当前队列为空或是下一条消息的执行时刻还未到来,next() 内部就会调用 native 层的 nativePollOnce 方法,让当前线程进入休眠阻塞状态,出让 CPU 资源,这个方法利用了 Linux 的 epoll 机制。当有新消息入队并调用前面提到的 nativeWake 唤醒它时,死循环才会继续执行。

拿到消息后,它会将消息交给在消息投递时绑定的 Handler 进行处理,调用它的 dispatchMessage(新版本中核心的分发逻辑被抽离到了 dispatchMessageImpl 中):

java 复制代码
// Handler.java

public void dispatchMessageImpl(@NonNull Message msg) {
    if (msg.callback != null) {
        // 消息自带的回调
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            // Handler 初始化时传入的回调 (Callback)
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        // Handler 自身的空实现,通常由子类重写
        handleMessage(msg);
    }
}

private static void handleCallback(Message message) {
    message.callback.run();
}

我们创建 Handler 时传入的 Lambda,对应的其实就是这里的 mCallback(Handler.Callback),它的 Boolean 返回值表示是否拦截消息:返回 true,dispatchMessageImpl 方法就直接结束了;如果返回 false,才会接着调用 Handler 自身的 handleMessage(msg)。

所以 Looper.loop() 的核心流程就是:从内部的消息队列中取消息(没有消息或时间没到就阻塞),然后分发给对应的 Handler 进行处理。回调所在的线程是当时调用 Looper.loop() 的那个线程(也就是前面的 mThread)。

性能优化:消息对象的回收与重用

然后简单说一下最后的消息回收 recycleUnchecked,消息有好几种归还的入口,该函数是框架内部使用的。

java 复制代码
// Message.java

@UnsupportedAppUsage
void recycleUnchecked() {
    if (MessageQueue.getUseConcurrent()) {
        clearReferenceFields();

        markInUse();
    } else {
        // 默认分支
        clear();
        synchronized (sPoolSync) {
            if (sPoolSize < MAX_POOL_SIZE) {
                next = sPool;
                sPool = this;
                sPoolSize++;
            }
        }
    }
}

void clear() {
    // Prevent accidental reuse such as if this Message is recycled.
    flags = FLAG_IN_USE;
    what = 0;
    arg1 = 0;
    arg2 = 0;
    obj = null;
    replyTo = null;
    sendingUid = UID_NONE;
    workSourceUid = UID_NONE;
    when = 0;
    target = null;
    callback = null;
    data = null;
    enqueueTime = -1;
    this.onClear(); // 空实现
}

直接看默认分支,它会清空消息的所有字段,同时往 Message 对象池(单链表结构)中头插放入。

后续调用 obtain() 时,将会复用消息对象,这主要是为了防止频繁创建对象,导致内存抖动和频繁的 GC,从而提升性能。

java 复制代码
public static Message obtain() {
    if (!MessageQueue.getUseConcurrent()) {
        synchronized (sPoolSync) {
            if (sPool != null) {
                Message m = sPool;
                sPool = m.next;
                m.next = null;
                m.flags = 0; // clear in-use flag
                sPoolSize--;
                return m;
            }
        }
    }
    // 消息池没有对象,才创建新的
    return new Message();
}

这里还有一个巧妙的防御措施:在清空方法 clear() 中,故意将 flags 标记为已使用(FLAG_IN_USE),防止消息进入对象池后被外部错误地再次入队或二次回收(一旦被误用,框架检测到该标记就会直接抛出异常拦截);直到后续在 obtain() 中真正被取出复用时,才会把这个标记清空。

相关推荐
GY-931 小时前
【Android】数据分层和依赖注入
android
传奇开心果编程3 小时前
【Jetpack Compose娓娓道来】第44课:持久化——让数据“关掉App也不丢”
android·kotlin·移动开发·数据持久化·jetpack compose·ui框架·声明式ui
星空孤辰3 小时前
【camera 008】android camera id 注册、状态监控等状态变化 全流程梳理
android·windows
恋猫de小郭4 小时前
iOS for Web ,把原生 iOS App 跑到进浏览器里面,倒反天罡
android·前端·ios
思想觉悟6 小时前
Android启动流程之点rc文件
android·linux·面试
_祝你今天愉快16 小时前
Android 高级绘制:[四] Canvas-实际案例操作
android
三少爷的鞋16 小时前
Android 工程师的技术信仰崩塌史
android
AirDroid_cn19 小时前
Android 15 权限回溯:已授予的麦克风权限如何批量回收?
android
Mr_万能胶20 小时前
官方发布,不烧心的 AOSP 编译提速技巧
android·ci/cd·架构