一、概述
Android消息机制主要是指 Handler 的运行机制以及 Handler 所附带的 MessageQueue 和 Looper 的工作过程。
在具体谈论这三者之间关系之前,先来了解一下什么叫异步消息处理线程。
异步消息处理线程启动后会进入一个无线的循环体之中,每循环一次,从其内部的消息队列中取出一个消息,然后回调相应的消息处理方法,执行完成后继续循环。当消息队列为空是,线程就会被阻塞等待。
这里无限循环和取消息是通过 Looper 来实现,消息队列指的就是MessageQueue,实为单链表,用来存放消息Message,Handler便是用来处理消息的。
Looper是一个特殊的概念,将一个普通线程变成一部消息处理线程就必须使其拥有 Looper,若需要使用 Handler 就必须为线程创建 Looper 。例如常用的主线程,也即UI线程,对应 ActivityThread,在其 main() 方法中创建时就会初始化 Looper,这也是在主线程中能使用 Handler 的原因。(详情可查看源码:ActivityThread.main())
下面先展示一段创建异步消息处理线程的代码:
Class LooperThread extends Thread {
private MyHandler mHandler;
class MyHandler extends Handler {
public MyHandler(String name) {
super(name);
}
@override
public void handleMessage(Message msg) {
// 处理消息
}
}
@override
public void run() {
Looper.prepare();
// do some initialization
mHandler = new MyHandler();
Looper.loop(); // 循环取消息
}
}
接下来先介绍一下 Looper、MessageQueue 以及 Handler 的工作原理,对上述有疑问的,可继续查看以下内容。
二、Looper 的工作原理
Looper 在 Android 的消息机制中扮演着消息循环的角色,具体来说就是一直不停地从 MessageQueue 中查看是否有新的消息,若有就立即取出处理,没有就会阻塞直到有新的消息。以下主要介绍的Looper 的 prepare()、构造和 loop() 方法。
1、 Looper.prepare() 方法
源码如下:
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));
}
首先会查看判断当前线程已经创建了 Looper ,如果已经创建了再次调用 prepare() 方法,就会抛异常,说明一个线程只会创建一次Looper;如果不存在,就创建一个 Looper 对象,并存放到 sThreadLocal 中。
Note:
简单介绍一下 sThreadLocal 这个 ThreadLocal 成员变量。
ThreadLocal是一个线程内部的数据存储类,通过它可以在指定的线程中存储数据,数据存储后,只有在指定的线程中可以获取到存储的数据,对于其他线程就无法获取到数据,也即 Looper 的作用域是以线程为作用域并且不同的线程拥有不同的 Looper,可通过 ThreadLocal 实现 Looper 在不同线程中的存取。*这里要记住一个线程只对应一个 Looper对象,如果在主线程中创建,就属于主线程,在子线程中创建就属于子线程。*
2、 Looper构造方法
源码如下:
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
在构造方法会创建一个 MessageQueue,也即消息队列,然后将当前的线程保存起来,也即保存创建 Looper 的线程。
3、 Looper.loop() 方法
主要代码如下:
public static void loop() {
// 从 sThreadLocal 中取出 Looper 对象
final Looper me = myLooper();
// 为空,代码当前线程没有主动调用 prepare() 方法
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
// 取出 Looper对应的 MessageQueue消息队列
final MessageQueue queue = me.mQueue;
// 开始执行无限循环
for (;;) {
// 从队列中取出一个Message 消息,next()在队列中没有消息时会阻塞操作
Message msg = queue.next(); // might block
// 这里当取出的消息为空时,是跳出循环的唯一条件
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
final long traceTag = me.mTraceTag;
if (traceTag != 0) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
try {
// msg.targert为Handler对象,最初由 Handler.sendMessage()发送的消息,最终交由Handler 处理
msg.target.dispatchMessage(msg);
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
msg.recycleUnchecked();
}
}
Q:loop() 退出循环的唯一条件是从消息队列中取出的消息为 null,那么何时才会为 null 呢?
A:虽然 mQueue.next() 是一个阻塞方法,当队列中没有消息时,会一直阻塞,当主动调用 Looper.quit() 和 quitSafely(boolean) 方法时,就会调用 MessageQueue.quit() 方法,通知消息队列退出,当消息队列被标记为退出状态时,它的 next() 方法就会返回 null。
Q:msg.target.dispatchMessage() 实际上是交给 Handler 处理,那么怎样交由对应的线程来处理呢?这个问题等到 Handler 工作原理时来解答。
二、Handler 的工作原理
Handler 的主要工作包括消息的发送和接收。消息的发送可以通过 post 的一系列方法以及 send 的一系列方法,不过最终都是通过 send 来实现的。
1、Handler.sendMessage() 方法
我们经常会使用这样的方式发送一条消息:
Message msg = new Message();
msg.what = 0x11;
msg.obj = "Hello, world !";
handler.sendMessage(msg);
查看 sendMessage() 方法源码可知,所有的 send() 和 post() 最终都会调用 handler.enqueueMessage(mQueue, msg, updateMillis) 方法,继续查看该方法源码如下:
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
// 设置 Message的 target成员变量为 Handler.this,将 Handler 和该 Message 绑定在一起
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
// 调用 MessageQueue 的进队方法
return queue.enqueueMessage(msg, uptimeMillis);
}
从上可知,Handler 发送消息的过程仅仅是向消息队列中插入一条消息,MessageQueue的 next() 方法就会返回这条消息给 Looper,Looper 收到消息就开始处理,最终消息由 Looper 交由 Handler 处理,也即 msg.target = handler.dispatchMessage()
方法被调用,这是消息就进入处理阶段。
2、Handler.dispatchMessage() 方法
消息处理方法dispatchMessage() 对应源码如下:
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
处理过程如下:
(1)首先,检查 Message 的 callback 是否为 null,不为 null,就调用 handleCallback(msg) 方法处理消息。
- Message 的 callback 为 Runnable 对象,实际上是通过 Handler.post(Runnable) 传递而来的,这里会调用
Message getPostMessage(Runnable r)
方法来给 msg 的 callback 赋值; - handleCallback(msg) 方法 逻辑只是执行:
message.callback.run();
(2)其次,检查 mCallback 接口是否为 null,不为 null,就回调 mCallback.handleMessage() 方法。
- 这里提供接口回调方法,就可以不用派生一个子类重写 handleMessage() 方法,可以直接回调 mCallback 的 handleMessage() 方法。
(3)最后,调用 handle.handleMessage() 方法来处理消息,也即当派生了子类时需要重写该方法。
3、Handler 构造方法
之前说过,在线程中使用 Handler 就必须先创建 Looper,通过查看 Handler 的构造方法可知,创建 Handler 时需要一个特定的 Looper 作为参数,如果没有传递 Looper 参数,就直接使用 Looper.myLooper() 方式获取。
大家知道,Looper 是作用于线程中的,一个线程仅对应一个 Looper,所以由该 Looper 创建的 Handler 和 MessageQueue 必定也是和该线程一一对应的,这也就能用来说明msg.target.dispatchMessage() 方法在处理消息时,一定也是在对应线程中处理的,也即若是在主线程中创建,则 Handler 对应在主线程中处理消息,若在子线程中创建,就会在子线程中处理消息,此时需要注意在这里是不能进行UI更新操作。
public Handler(Looper looper) {
this(looper, null, false);
}
public Handler(Looper looper, Callback callback, boolean async) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
public Handler(Callback callback, boolean async) {
// 因为是从 ThreadLocal 中获取,所以是从创建了 Looper 的线程中获取
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
三、MessageQueue 的工作原理
消息队列 MessageQueue 主要包含两个操作:插入和读取。读取操作也即取出一条 Message消息,随后这条消息就会从消息队列中移除。
需要注意得是消息队列内部实现并不是队列,而是通过一个 单链表来处理的(单链表插入和移除有优势)。
1、enqueueMessage(Message, long) 方法
消息Message 创建后,由 Handler.sendMessage(),然后插入到 MessageQueue,主要源码如下:
boolean enqueueMessage(Message msg, long when) {
// Handler 对象不能为空
if (msg.target == null) {
throw new IllegalArgumentException("Message must have a target.");
}
if (msg.isInUse()) {
throw new IllegalStateException(msg + " This message is already in use.");
}
synchronized (this) {
// 调用 Looper.quit()实际是调用 mQueue.quit()终止消息循环
if (mQuitting) {
IllegalStateException e = new IllegalStateException(
msg.target + " sending message to a Handler on a dead thread");
msg.recycle();
return false;
}
msg.markInUse();
msg.when = when;
Message p = mMessages;
boolean needWake;
if (p == null || when == 0 || when < p.when) {
// New head, wake up the event queue if blocked. (单链表操作:若第一次创建,则先创建头结点)
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
// Inserted within the middle of the queue. Usually we don't have to wake
// up the event queue unless there is a barrier at the head of the queue
// and the message is the earliest asynchronous message in the queue.
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; // invariant: p == prev.next
prev.next = msg;
}
// We can assume mPtr != 0 because mQuitting is false.
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
2、Message next() 方法
next() 方法是一个无限循环的方法for(;;)
,会出现以下几种情况:
(1)当调用 Looper.quit() -> mQueue.quit() 停止消息循环,直接返回 null;
(2)若消息队列中没有消息,next() 方法就会一直被阻塞(如何判断队列中没有消息呢?根据闲置的Handler 个数来判断,当没有闲置的 Handler 时,就阻塞队列?);
(3)当有新消息时,next() 方法会返回这条消息 并从单链表 / 消息队列中将其移除。
具体代码如下:
Message next() {
// Return here if the message loop has already quit and been disposed.
// This can happen if the application tries to restart a looper after quit
// which is not supported.
final long ptr = mPtr;
if (ptr == 0) {
return null;
}
int pendingIdleHandlerCount = -1; // -1 only during first iteration
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
// Try to retrieve the next message. Return if found.
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
// ??????找到下一个异步消息
if (msg != null && msg.target == null) {
// Stalled by a barrier. Find the next asynchronous message in the queue.
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {
if (now < msg.when) {
// Next message is not ready. Set a timeout to wake up when it is ready.
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// Got a message. 取出消息并返回
mBlocked = false;
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
if (DEBUG) Log.v(TAG, "Returning message: " + msg);
msg.markInUse();
return msg;
}
} else {
// No more messages.
nextPollTimeoutMillis = -1;
}
// Process the quit message now that all pending messages have been handled.
if (mQuitting) {
dispose();
return null;
}
// If first time idle, then get the number of idlers to run.
// Idle handles only run if the queue is empty or if the first message
// in the queue (possibly a barrier) is due to be handled in the future.
if (pendingIdleHandlerCount < 0
&& (mMessages == null || now < mMessages.when)) {
pendingIdleHandlerCount = mIdleHandlers.size();
}
if (pendingIdleHandlerCount <= 0) {
// No idle handlers to run. Loop and wait some more.
mBlocked = true;
continue;
}
if (mPendingIdleHandlers == null) {
mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
}
mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
}
// Run the idle handlers.
// We only ever reach this code block during the first iteration.
for (int i = 0; i < pendingIdleHandlerCount; i++) {
final IdleHandler idler = mPendingIdleHandlers[i];
mPendingIdleHandlers[i] = null; // release the reference to the handler
boolean keep = false;
try {
keep = idler.queueIdle();
} catch (Throwable t) {
Log.wtf(TAG, "IdleHandler threw exception", t);
}
if (!keep) {
synchronized (this) {
mIdleHandlers.remove(idler);
}
}
}
// Reset the idle handler count to 0 so we do not run them again.
pendingIdleHandlerCount = 0;
// While calling an idle handler, a new message could have been delivered
// so go back and look again for a pending message without waiting.
nextPollTimeoutMillis = 0;
}
}
四、Message 对象
Message 也即消息实体,实现了Parcelable接口,所以是可用于进程间通信。
首先来讲下如何创建 Message的,官方推荐使用 Message.obtain()
或者 Handler.obtainMessage()
方法来创建 Message 对象,而不建议使用构造方法创建,前者是如果回收池中存在,就直接从已回收的对象池中获取,不用重新分配内存,否则就重新创建,后者直接构造,每次都需要从堆中分配内存,具体实现可看 Message.obtain() 方法:
public static Message obtain() {
synchronized (sPoolSync) {
// 如果是第一条消息,就会直接创建
if (sPool != null) { // sPool为静态Message对象
Message m = sPool;
sPool = m.next;
m.next = null;
m.flags = 0; // clear in-use flag
sPoolSize--;
return m;
}
}
return new Message();
}
sPool 是一个 静态Message 对象,它被赋值是在 Message.recycleUnchecked() 方法中,此方法就是回收一个不再 in-use 的 message,消息回收后,就会清除该 Message.this 的所有信息(成员变量值),并且当消息回收池中的消息的 size 没有超过最大数量 MAX_POOL_SIZE = 50 时,会将回收的该条消息保存在 sPool 中。
由此可知一条 Message 从创建到回收的过程如下:
(1)当使用 Message.obtain() 创建消息时,如果是该线程消息队列中的第一条 Message,就会直接 new Message();
(2)当消息被处理完毕被回收时,会将该条消息的引用保存到 sPool 中,sPoolSize 累计加 1;
(3)当创建第二条消息时,sPool != null,将 sPool 赋值给一个 Message 对象,这样 m就指向了之前回收的对象的内存地址,然后将 sPool 指向下一个被回收的对象,sPoolSize 减 1,,返回对象 m,如此便不用重新申请内存空间。
五、Android 消息处理机制总流程图
![](https://i-blog.csdnimg.cn/blog_migrate/5ddc98cce352e6038c8d121d3935919c.webp?x-image-process=image/format,png)