从一段熟悉的通信代码说起
Handler 的使用,大家应该都很熟悉了,比如我们经常用它来在子线程中更新 UI:
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:
// 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:
// 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 中的队列。
// 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 性能会更好,但是我们就不看它了。
// 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:
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,以及消息的计划执行时刻。
如果你连续发送了三条消息:
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,按我们之前的分析,应该是这样的吧:
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 分支中,将消息放到链表尾部。
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 取消息时的阻塞机制是对应的。
if (needWake) {
nativeWake(mPtr);
}
消息分发:Looper 的死循环与线程隔离
如果在子线程中直接获取 Looper 创建 Handler 并发送消息,会报异常。
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():
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():
// 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));
}
// 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,确保消息的分发不会在多线程间错乱。
// Looper.java
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
创建 Looper 对象中,初始化了消息队列,以及记录创建时所在的线程。
之前调用的 Looper.myLooper(),就会从当前线程中的 threadLocals 拿刚刚放入的 Looper 对象。
// Looper.java
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
// 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()。
// 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() 源码很长,所以做了一些省略:
// 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 中):
// 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,消息有好几种归还的入口,该函数是框架内部使用的。
// 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,从而提升性能。
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() 中真正被取出复用时,才会把这个标记清空。