前言
阅读本文，可以了解如下问题：
1、Handler如何处理和分发消息？
2、Looper如何避免一直轮询？
3、通过sendMessageAtTime()发送的Message，是如何控制时间的？
4、 同步分割栏的含义和使用？
概述
发送者
消息队列
循环处理
线程1 ... 线程2 ...
1. Hander、Looper、MessageQueue三者的关系
MessageQueue是Looper构造方法中创建
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
Hander构造方法
public Handler(Callback callback, boolean async) {
.....
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread " + Thread.currentThread()
+ " that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
2. 运行机制
创建Looper对象
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));
}
如果要实现Handler消息机制，必须要有Looper对象，我们在应用主线程可以通过handler发送message，是因为在应用进程创建的初始，ActivityThread.java的main()中已经通过调用Looper.java 的 prepareMainLooper()方法创立了主线程的Looper对象。
Looper对象创建后，还没有真正运行起来，需要调用其loop()方法，让它“跑”起来：
public static void loop() {
final Looper me = myLooper();
......
final MessageQueue queue = me.mQueue;
......
// for 循环一直在运行
for (;;) {
// 如果消息队列没有msg，就会阻塞在下面这句，直到消息返回
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
......
// 从消息队列获得消息，分发给对应的handler，这里target就是handler对象
msg.target.dispatchMessage(msg);
.......
}
}
这个for循环就是消息处理机制的“循环泵”，不断的从消息队列获取消息，然后分发给对应的handler处理，后面会详细介绍queue.next()方法的实现原理。
public void dispatchMessage(@NonNull Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
向消息队列MessageQueue发送message
sendMessage() 最终会调用如下方法：
Handler.java
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);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);//异步消息，其实没有什么多大的作用，后面介绍同步分割栏再说
}
return queue.enqueueMessage(msg, uptimeMillis);
}
把消息插入到消息队列中：
MessageQueue.java
boolean enqueueMessage(Message msg, long when) {
synchronized (this) {
......
msg.when = when;
Message p = mMessages;
boolean needWake;
// 1.如果正在插入的消息的执行时间比消息队列的消息头还早，就把它插入头部
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 {
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
// 2.否则，遍历消息队列，找到合适的位置插入
// 这里可以看出，消息队列中的消息都是按照时间排序的，最早执行的在列表头部
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); // 重要：msg插入队列后，如果needwake为true，就会唤醒loop()方法中的阻塞返回
}
}
return true;
}
Looper循环处理消息
现在终于到了消息分发机制的核心代码loop()，主要来看看其中queue.next()的实现
public static void loop() {
final Looper me = myLooper();
......
final MessageQueue queue = me.mQueue;
......
// for 循环一直在运行
for (;;) {
// 如果消息队列没有msg，就会阻塞在下面这句，直到消息返回
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
......
// 从消息队列获得消息，分发给对应的handler，这里target就是handler对象
msg.target.dispatchMessage(msg);
.......
}
}
Message next() {
//nextPollTimeoutMillis代表需要阻塞的时间，这个时间需要根据message的执行时间计算得来的，下面的for循环就是在计算这个时间
int nextPollTimeoutMillis = 0;
for (;;) {
//此方法会阻塞，开始nextPollTimeoutMillis为0，直接返回
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
// 遇到同步分割栏，绕过正常msg，寻找后面异步msg
// 同步分割栏后面再介绍
if (msg != null && msg.target == null) {
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 {
// 否则直接返回msg
mBlocked = false;
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
msg.markInUse();
return msg;
}
} else {
// "-1"表示阻塞，nativePollOnce(ptr, -1)方法就会等待有新的msg到来
nextPollTimeoutMillis = -1;
}
......
}
}
来看看nativePollOnce()如何实现的，这是一个native方法，jni方法：
frameworks/base/core/jni/android_os_MessageQueue.cpp
static void android_os_MessageQueue_nativePollOnce(JNIEnv* env, jobject obj,
jlong ptr, jint timeoutMillis) {
NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr);
nativeMessageQueue->pollOnce(env, obj, timeoutMillis);
}
void NativeMessageQueue::pollOnce(JNIEnv* env, jobject pollObj, int timeoutMillis) {
mPollEnv = env;
mPollObj = pollObj;
//主要看这个pollOnce()方法
mLooper->pollOnce(timeoutMillis);
mPollObj = NULL;
mPollEnv = NULL;
}
system/core/libutils/Looper.cpp
int Looper::pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData) {
int result = 0;
......
result = pollInner(timeoutMillis); // 调用pollInner方法
}
int Looper::pollInner(int timeoutMillis) {
// Adjust the timeout based on when the next message is due.
if (timeoutMillis != 0 && mNextMessageUptime != LLONG_MAX) {
nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
int messageTimeoutMillis = toMillisecondTimeoutDelay(now, mNextMessageUptime);
if (messageTimeoutMillis >= 0
&& (timeoutMillis < 0 || messageTimeoutMillis < timeoutMillis)) {
timeoutMillis = messageTimeoutMillis;
}
// Poll.
int result = POLL_WAKE;
struct epoll_event eventItems[EPOLL_MAX_EVENTS];
// 省略其它代码，直接看epoll_wait()，这个方法就是监听fd是否有写入，如果有写入，就立即返回，否则等待timeoutMillis后再返回
// 关于epoll_wait()的介绍，可以自行百度
int eventCount = epoll_wait(mEpollFd.get(), eventItems, EPOLL_MAX_EVENTS, timeoutMillis);
......
return result;
}
再来看看nativeWake()方法的实现：
void NativeMessageQueue::wake() {
mLooper->wake();
}
void Looper::wake() {
uint64_t inc = 1;
//唤醒的方式就是向mWakeEventFd写入“1”
ssize_t nWrite = TEMP_FAILURE_RETRY(write(mWakeEventFd.get(), &inc, sizeof(uint64_t)));
......
}
3. 什么是同步分割栏
当设置了同步屏障之后，next() 将会忽略所有的同步消息，返回异步消息。
也就是设置了同步屏障之后，Handler只会处理异步消息。换句话说，同步屏障为Handler消息机制增加了一种简单的优先级机制，异步消息的优先级要高于同步消息。
Message next() {
//...
int pendingIdleHandlerCount = -1; // -1 only during first iteration
int nextPollTimeoutMillis = 0;
for (;;) {
//...
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 while循环遍历消息链表
// 跳出循环时，msg指向离表头最近的一个异步消息
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {
if (now < msg.when) {
//...
} else {
// Got a message.
mBlocked = false;
if (prevMsg != null) {
//将msg从消息链表中移除
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;
}
//...
}
//...
}
}
同步分割栏的应用
Android应用框架中为了更快的响应UI刷新事件在ViewRootImpl.scheduleTraversals中使用了同步屏障
void scheduleTraversals() {
if (!mTraversalScheduled) {
mTraversalScheduled = true;
//设置同步障碍，确保mTraversalRunnable优先被执行
mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
//内部通过Handler发送了一个异步消息
mChoreographer.postCallback(
Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
if (!mUnbufferedInputDispatch) {
scheduleConsumeBatchedInput();
}
notifyRendererOfFramePending();
pokeDrawLockIfNeeded();
}
}
mTraversalRunnable调用了performTraversals执行measure、layout、draw
为了让mTraversalRunnable尽快被执行，在发消息之前调用MessageQueue.postSyncBarrier设置了同步屏障
