1.消息机制简述
- 准备阶段
- 在子线程中调用Looper.prepare()方法或者在主线程调用Looper.prepareMainLooper()方法创建当前的Looper对象（主线程中这一步由Android系统在应用启动时完成）
- 在创建Looper对象时会创建一个消息队列MessageQueue
- Looper通过loop()方法获取到当前线程的Looper并启动循环，从MessageQueue不断提取Message，若MessageQueue没有消息，处于阻塞状态。
- 发送消息
- 使用当前线程创建的Handler在其他线程通过调用sendMessage()发送Message到MessageQueue
- MessageQueue插入新的Message并唤醒阻塞
- 获取消息
- 重新检查MessageQueue并获取新插入的消息Message
- Looper获取Message后，通过Message的target即Handler调用dispatchMessage(Message msg)方法分发提取到的Message，然后回收Message并循环获取下一个Message
- Handler使用handlerMessage(Message msg)方法处理Message
- 阻塞等待
- MessageQueue没有Message时，重新进入阻塞状态
1.1 注意事项
- MessageQueue叫做消息队列，但是内部存储结构并不是真正的队列，而是采用单链表的数据结构来存储消息列表。
2. 准备阶段
2.1 prepare
- 调用Looper.prepare会创建一个Looper对象
- 调用Looper.prepare时会创建MessageQueue
- 调用Looper.prepare时会将Looper对象存储到ThreadLocal中
源代码如下：
//Looper.class
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");
}
//将Looper存到当前线程的ThreadLocal中
sThreadLocal.set(new Looper(quitAllowed));
}
private Looper(boolean quitAllowed) {
//创建MessageQueue
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
2.2 loop
- loop方法用于从MessageQueue中取出待处理的消息，会调用MessageQueue的next方法来获取消息，如果MessageQueue中没有消息，Looper就会一直阻塞等待，除非MessageQueue返回null才退出消息的循环监听。
- 调用Looper的prepare方法后会创建MessageQueue和Looper。但需要调用Looper的loop方法才会开启消息循环，Looper才会开始循环监听MessageQueue中的消息
- Looper取到消息后，会调用消息Message所对应的Handler的dispatchMessage方法来处理消息。这样Handler的dispatchMessage方法就会在Looper所在的线程中执行了。
loop源码如下
public static void loop() {
final Looper me = myLooper(); // 获取当前线程的 Looper 对象
if (me == null) { // 当前线程没有 Looper 对象则抛出异常
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue; // 获取到当前线程的消息队列
// 清空远程调用端进程的身份，用本地进程的身份代替，确保此线程的身份是本地进程的身份，并跟踪该身份令牌
// 这里主要用于保证消息处理是发生在当前 Looper 所在的线程
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
// 无限循环
for (;;) {
Message msg = queue.next(); // 从消息队列中获取消息，因为next是个无限循环，所以loop方法也会阻塞
if (msg == null) {
// 没有消息则退出循环，正常情况下不会退出的，只会阻塞在上一步，直到有消息插入并唤醒返回消息,只有在调用MessageQueue的quit方法后MessageQueue才会返回null，才会退出循环监听
return;
}
// 默认为 null，可通过 setMessageLogging() 方法来指定输出，用于 debug 功能
final Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
// 开始跟踪，并写入跟踪消息，用于 debug 功能
final long traceTag = me.mTraceTag;
if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
try {
// 通过 Handler 分发消息
msg.target.dispatchMessage(msg);
} finally {
// 停止跟踪
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
// 确保在分发消息的过程中线程的身份没有改变，如果改变则发出警告
final long newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
Log.wtf(TAG, "Thread identity changed from 0x"
+ Long.toHexString(ident) + " to 0x"
+ Long.toHexString(newIdent) + " while dispatching to "
+ msg.target.getClass().getName() + " "
+ msg.callback + " what=" + msg.what);
}
msg.recycleUnchecked(); // 回收消息，将 Message 放入消息池
}
}
3 发送消息
3.1 Handler
handler的一般使用如下所示：
//方式一
private static class MyHandler extends Handler {
@Override
public void handleMessage(Message message) {
switch (message.what) {
case MESSAGE_TAG:
Log.d(Thread.currentThread().getName(),"receive message");
break;
default:
break;
}
}
}
//方式二
private Handler handler = new Handler(){
@Override
public void handleMessage(Message msg) {
...
}
}
- 调用无参构造函数时，最终会调用public Handler(Callback callback, boolean async)方法，不过callback为空，async为false
- 通过调用Looper.myLooper()方法来获取Looper实例。
final Looper mLooper;
final MessageQueue mQueue;
final Callback mCallback;
final boolean mAsynchronous; /**
* Default constructor associates this handler with the {@link Looper} for the
* current thread.
*
* If this thread does not have a looper, this handler won't be able to receive messages
* so an exception is thrown.
*/
public Handler() {
this(null, false);
} /**
* Use the {@link Looper} for the current thread with the specified callback interface
* and set whether the handler should be asynchronous.
*
* Handlers are synchronous by default unless this constructor is used to make
* one that is strictly asynchronous.
*
* Asynchronous messages represent interrupts or events that do not require global ordering
* with respect to synchronous messages. Asynchronous messages are not subject to
* the synchronization barriers introduced by {@link MessageQueue#enqueueSyncBarrier(long)}.
*
* @param callback The callback interface in which to handle messages, or null.
* @param async If true, the handler calls {@link Message#setAsynchronous(boolean)} for
* each {@link Message} that is sent to it or {@link Runnable} that is posted to it.
*
* @hide
*/
public Handler(Callback callback, boolean async) {
if (FIND_POTENTIAL_LEAKS) {
final Class<? extends Handler> klass = getClass();
if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) && (klass.getModifiers() & Modifier.STATIC) == 0) {
Log.w(TAG, "The following Handler class should be static or leaks might occur: " + klass.getCanonicalName());
}
}
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;
}
handler通过sendMessage将消息发送到消息队列
public final boolean sendMessage(Message msg) {
return sendMessageDelayed(msg, 0);
}
public final boolean sendMessageDelayed(Message msg, long delayMillis) {
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
/**
* Enqueue a message into the message queue after all pending messages
* before the absolute time (in milliseconds) <var>uptimeMillis</var>.
* <b>The time-base is {@link android.os.SystemClock#uptimeMillis}.</b>
* Time spent in deep sleep will add an additional delay to execution.
* You will receive it in {@link #handleMessage}, in the thread attached
* to this handler.
*
* @param uptimeMillis The absolute time at which the message should be
* delivered, using the
* {@link android.os.SystemClock#uptimeMillis} time-base.
*
* @return Returns true if the message was successfully placed in to the
* message queue. Returns false on failure, usually because the
* looper processing the message queue is exiting. Note that a
* result of true does not mean the message will be processed -- if
* the looper is quit before the delivery time of the message
* occurs then the message will be dropped.
*/
public boolean sendMessageAtTime(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);
}
Looper获取到消息后，最后会交给Handler的dispatchMessage方法分发
//Handler.class
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
3.2 ThreadLocal
ThreadLocal是一个线程内部的数据存储类，通过它可以在指定的线程中存储数据，数据存储以后，只有在指定线程中可以获取到存储的数据，对于其它线程来说无法获取到数据。
示例：分别在主线程、子线程1和子线程2中设置和访问它的值
private ThreadLocal<Boolean>mBooleanThreadLocal = new ThreadLocal<Boolean>();
...
mBooleanThreadLocal.set(true);
Log.d(TAG, "[Thread#main]mBooleanThreadLocal=" + mBooleanThreadLocal.get());
new Thread("Thread#1") {
@Override
public void run() {
mBooleanThreadLocal.set(false);
Log.d(TAG, "[Thread#1]mBooleanThreadLocal=" + mBooleanThreadLocal.get());
};
}.start();
new Thread("Thread#2") {
@Override
public void run() {
Log.d(TAG, "[Thread#2]mBooleanThreadLocal=" + mBooleanThreadLocal.get());
};
}.start();
结果：
D/TestActivity(8676):[Thread#main]mBooleanThreadLocal=true
D/TestActivity(8676):[Thread#1]mBooleanThreadLocal=false
D/TestActivity(8676):[Thread#2]mBooleanThreadLocal=null
从上面日志可以看出，虽然在不同线程中访问的是同一个ThreadLocal对象，但是它们通过ThreadLocal来获取到的值却是不一样的，这就是ThreadLocal的奇妙之处。ThreadLocal之所以有这么奇妙的效果，是因为不同线程访问同一个ThreadLocal的get方法，ThreadLocal内部会从各自的线程中取出一个数组，然后再从数组中根据当前ThreadLocal的索引去查找出对应的value值，很显然，不同线程中的数组是不同的，这就是为什么通过ThreadLocal可以在不同的线程中维护一套数据的副本并且彼此互不干扰。
- ThreadLocal的set方法
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
- createMap方法
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
...
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
table = new Entry[INITIAL_CAPACITY];
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
etThreshold(INITIAL_CAPACITY);
}
- ThreadLocal的get方法
public T get() {
Thread t = Thread.currentThread();
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();
}
4 获取消息
4.1 MessageQueue
- enqueueMessage() 方法中的 MessageQueue 对象来自于 Handler 的 mQueue 属性
- MessageQueue 是消息队列，Handler 发送消息其实就是将 Message 对象插入到消息队列中，该消息队列也是使用了链表的数据结构。
- MessageQueue 在实例化时会传入 quitAllowed 参数，用于标识消息队列是否可以退出，由 ActivityThread 中 Looper 的创建可知，主线程的消息队列不可以退出。
- MessageQueue 根据消息的触发时间，将新消息插入到合适的位置，保证所有的消息的时间顺序。
MessageQueue 插入消息：
boolean enqueueMessage(Message msg, long when) {
if (msg.target == null) { // target 即 Handler 不允许为 null
throw new IllegalArgumentException("Message must have a target.");
}
if (msg.isInUse()) { // 是否在被使用
throw new IllegalStateException(msg + " This message is already in use.");
}
synchronized (this) {
if (mQuitting) { // 是否正在退出消息队列
IllegalStateException e = new IllegalStateException(
msg.target + " sending message to a Handler on a dead thread");
Log.w(TAG, e.getMessage(), e);
msg.recycle(); // 回收 Message，回收到消息池
return false;
}
msg.markInUse(); // 标记为正在使用
msg.when = when;
Message p = mMessages; // 获取当前消息队列中的第一条消息
boolean needWake;
if (p == null || when == 0 || when < p.when) {
// 消息队列为空 或 新消息的触发时间为 0 或 新消息的触发时间比消息队列的第一条消息的触发时间早
// 将新消息插入到队列的头，作为消息队列的第一条消息。
msg.next = p;
mMessages = msg;
needWake = mBlocked; // 当阻塞时需要唤醒
} else {
// 将新消息插入到消息队列中（非队列头）
// 当阻塞 且 消息队列头是 Barrier 类型的消息（消息队列中一种特殊的消息，可以看作消息屏障，用于拦截同步消息，放行异步消息） 且 当前消息是异步的 时需要唤醒
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
// 循环消息队列，比较新消息的触发时间和队列中消息的触发时间，将新消息插入到合适的位置
for (;;) {
prev = p; // 将前一条消息赋值给 prev
p = p.next; // 将下一条消息赋值给 p
if (p == null || when < p.when) {
// 如果已经是消息队列中的最后一条消息 或 新消息的触发时间比较早 则退出循环
break;
}
if (needWake && p.isAsynchronous()) {
// 需要唤醒 且 下一条消息是异步的 则不需要唤醒
needWake = false;
}
}
// 将新消息插入队列
msg.next = p;
prev.next = msg;
}
if (needWake) {
// 如果需要唤醒调用 native 方法唤醒
nativeWake(mPtr);
}
}
return true;
}
从消息队列中获取消息，通过MessageQueue里面的next方法实现
Message next() {
// 如果消息队列退出，则直接返回
// 正常运行的应用程序主线程的消息队列是不会退出的，一旦退出则应用程序就会崩溃
final long ptr = mPtr;
if (ptr == 0) {
return null;
}
int pendingIdleHandlerCount = -1; // 记录空闲时处理的 IdlerHandler 数量，可先忽略
int nextPollTimeoutMillis = 0; // native 层使用的变量，设置的阻塞超时时长
// 开始循环获取消息
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
// 调用 native 方法阻塞，当等待nextPollTimeoutMillis时长，或者消息队列被唤醒，都会停止阻塞
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
// 尝试获取下一条消息，获取到则返回该消息
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages; // 获取消息队列中的第一条消息
if (msg != null && msg.target == null) {
// 如果 msg 为 Barrier 类型的消息，则拦截所有同步消息，获取第一个异步消息
// 循环获取第一个异步消息
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {
if (now < msg.when) {
// 如果 msg 的触发时间还没有到，设置阻塞超时时长
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// 获取消息并返回
mBlocked = false;
if (prevMsg != null) {
// 如果 msg 不是消息队列的第一条消息，上一条消息的 next 指向 msg 的 next。
prevMsg.next = msg.next;
} else {
// 如果 msg 是消息队列的第一条消息，则 msg 的 next 作为消息队列的第一条消息 // msg 的 next 置空，表示从消息队列中取出了 msg。
mMessages = msg.next;
}
msg.next = null; // msg 的 next 置空，表示从消息队列中取出了 msg
if (DEBUG) Log.v(TAG, "Returning message: " + msg);
msg.markInUse(); // 标记 msg 为正在使用
return msg; // 返回该消息，退出循环
}
} else {
// 如果没有消息，则设置阻塞时长为无限，直到被唤醒
nextPollTimeoutMillis = -1;
}
// 如果消息正在退出，则返回 null
// 正常运行的应用程序主线程的消息队列是不会退出的，一旦退出则应用程序就会崩溃
if (mQuitting) {
dispose();
return null;
}
// 第一次循环 且 （消息队列为空 或 消息队列的第一个消息的触发时间还没有到）时，表示处于空闲状态
// 获取到 IdleHandler 数量
if (pendingIdleHandlerCount < 0
&& (mMessages == null || now < mMessages.when)) {
pendingIdleHandlerCount = mIdleHandlers.size();
}
if (pendingIdleHandlerCount <= 0) {
// 没有 IdleHandler 需要运行，循环并等待
mBlocked = true; // 设置阻塞状态为 true
continue;
}
if (mPendingIdleHandlers == null) {
mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
}
mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
}
// 运行 IdleHandler，只有第一次循环时才会运行
for (int i = 0; i < pendingIdleHandlerCount; i++) {
final IdleHandler idler = mPendingIdleHandlers[i];
mPendingIdleHandlers[i] = null; // 释放 IdleHandler 的引用
boolean keep = false;
try {
keep = idler.queueIdle(); // 执行 IdleHandler 的方法
} catch (Throwable t) {
Log.wtf(TAG, "IdleHandler threw exception", t);
}
if (!keep) {
synchronized (this) {
mIdleHandlers.remove(idler); // 移除 IdleHandler
}
}
}
// 重置 IdleHandler 的数量为 0，确保不会重复运行
// pendingIdleHandlerCount 置为 0 后，上面可以通过 pendingIdleHandlerCount < 0 判断是否是第一次循环，不是第一次循环则 pendingIdleHandlerCount 的值不会变，始终为 0。
pendingIdleHandlerCount = 0;
// 在执行 IdleHandler 后，可能有新的消息插入或消息队列中的消息到了触发时间，所以将 nextPollTimeoutMillis 置为 0，表示不需要阻塞，重新检查消息队列。
nextPollTimeoutMillis = 0;
}
}
总结
消息处理顺序
- 准备
（1）如果在子线程里接收并处理消息，则需要调用Looper.prepare()方法；如果在主线程里接收并处理消息，则不用自己调用prepare方法，因为在初始化Activity时，系统已经初始化了一个Looper，Looper.prepareMainLooper()
（2）调用Looper.loop()方法获得当前线程的Looper对象，并循环从MessageQueue中获取消息，如果消息为空，则阻塞 - 发送消息
（1）创建并初始化Handler对象，在需要发送消息的线程里调用handler.sendMessage(msg);
（2）通过handler.sendMessage(msg)发送的消息最终会调用enqueueMessage将消息插入到消息队列中 - 获取消息
（1）通过Looper的loop方法循环获取MessageQueue里的消息，如果消息队列里的消息为空，则阻塞，否则取出消息
（2）获取到MessageQueue里面的消息后，通过handler的dispatchMessage来分发消息
（3）然后Handler通过handlerMessage方法来处理得到的消息 - 所有消息处理完后进入阻塞状态
参考文献：
//www.greatytc.com/p/3b8c2dbf1124
https://yq.aliyun.com/articles/649873
https://blog.csdn.net/singwhatiwanna/article/details/48350919
