Handler源码学习（一）流程
Handler源码学习（二）Message对象池
Handler源码学习（三）MessageQueue入队插队
1.消息入队
消息队列与Message对象池的结构很像，也是通过对象之间通过next指向形成链表结构
这时候加入一个msg消息，先来看如果消息队列为空的情况
//判断消息队列为空时，会直接将这个msg赋值给mMessage，并将p赋值给msg.next，这时next当然时null
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，从字面意思理解是前一个message的意思
Message prev;
for (;;) {
//接着进入一个死循环，将p赋值给prev，看看前面的代码可以知道，p指向的是mMessages,所以这里
//是将prev指向了mMessage，再下一次循环的时候，prev则是指向了第二个message，依次类推
prev = p;
//接着将p指向p.next也就是mMessages.next,也就是消息链表中的第二个message
p = p.next;
//接下来判断两件事
//1.p==null，说明没有下一个消息了，跳出循环
//2.p!=null，并且当前需要入队的这个message的执行时间是小于队列中这个任务的执行时间的
//也就是说这个入队的message需要比队列中的这个message先执行，也跳出循环
//3.如果这两个条件都不满足的话，则继续跟队列中的下一个消息进行对比，直到满足条件，或者到
//队列的末尾
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
//跳出循环后做了两件事情
// 1.将入队的这个消息的next指向循环中获取到的应该排在这个消息之后的message
msg.next = p; // invariant: p == prev.next
//将msg前面那个message.next指向了msg
prev.next = msg;
//到这里就将一个message完成了入队
//入队的过程是线程安全的
}
MessageQueue入队.jpg
MessageQueue入队（2）.jpg
2.取出消息
这里贴的不是完整代码，而是取出message的核心逻辑代码，这里其实分了两个部分，第一个部分是消息插队，这个在第三节叙述，第二个部分是正常的消息，其实取出消息的部分比较简单，注释也比较清晰
synchronized (this) {
// Try to retrieve the next message. Return if found.
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
//队列的第一个message
Message msg = mMessages;
//正常取出消息
if (msg != null) {
//1.首先判断当前时间是否小于了msg的执行时间，
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;
}
3.消息插队
首先需要知道的是整个android系统其实主要是依赖消息机制来处理事件，比如说点击事件等等，都是通过handler发送消息进行处理，但是这些系统消息相较于程序自己发送的消息，应该要优先执行，所以就涉及到了消息插队
- isAsynchronous() — 如何将系统消息和程序发送的消息区分开来
在阅读Hanlder的源码的时候，可以看到一个@hide的构造方法，传入一个布尔值，从字面意思理解是异步
public Handler(boolean async) {
this(null, async);
}
mAsynchronous = async;//赋值给mAsychronous
//消息入队的时候，msg.setAsynchronous(true);将这个msg标记为异步
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
为什么要标记为异步呢？是要新开一个线程来执行么？可是最后也是发送到looper所绑定的消息队列中啊，貌似这里并没有异步，接着看上一节提到的消息插队的源码，在这里看到调用了一个方法msg.isAsynchronous()，貌似这个布尔值并不是跟异步有关系，而是将这个消息做了一个标记而已
前面的消息入队分析可以知道，虽然被标记了系统消息，但是还是按照消息队列的规则去入队，那么如何做到优先取出这个任务呢，一步步看
Message prevMsg = null;
Message msg = mMessages;
//1.判断当前第一个消息不为空
//2.重点来了,msg.target == null,如果这个消息的target为空，看过handler源码可以知道，
//只要是通过handler发送消息，就会将这个msg的target指向发送消息的handler，否则也无法处理这个消息
//那么为什么这里会出现target为空呢？先看if代码块里面的代码
if (msg != null && msg.target == null) {
// Stalled by a barrier. Find the next asynchronous message in the queue.
//进入一个循环，注意while中的判断条件
do {
//不断地取下一个消息来匹配判断条件
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
//只有当msg不为空 并且当前的这个消息是异步的，也就是说是系统消息，则跳出循环。
//跳出循环后就走到了正常取消息的代码中，取出的正是这个系统消息，发现插队就成功了
}
上面的分析已经插队成功，但是还有疑点，到底是怎么进入到if代码块中的
// Stalled by a barrier. Find the next asynchronous message in the queue.
作者在这里给了一条注释，通过一个阻塞块来停止正常的队列，找到队列中的第一个系统消息
在MessageQueue中试图搜索barrier，发现一个方法，
public int postSyncBarrier() {
return postSyncBarrier(SystemClock.uptimeMillis());
}
private int postSyncBarrier(long when) {
// Enqueue a new sync barrier token.
// We don't need to wake the queue because the purpose of a barrier is to stall it.
synchronized (this) {
final int token = mNextBarrierToken++;
final Message msg = Message.obtain();
msg.markInUse();
msg.when = when;
msg.arg1 = token;
Message prev = null;
Message p = mMessages;
//判断将这个消息插入到队列中的哪个位置
if (when != 0) {
while (p != null && p.when <= when) {
prev = p;
p = p.next;
}
}
if (prev != null) { // invariant: p == prev.next
msg.next = p;
prev.next = msg;
} else {
msg.next = p;
mMessages = msg;
}
return token;
}
}
加入队列的代码已经很熟悉了，可以看到在这段代码中其实入队了一个没有target的消息，而最上面那个public方法中可以看到传入的when是当前的系统时间，也就是说如果调用这个方法会在消息队列的头部插入一个没有target的message，到这里思路就比较清晰了，但是这个消息肯定不能一直在队列中，否则整个队列的正常消息就永远无法处理，所以相对应还有一个remove。注释中说明，这个方法应该跟插入的方法匹配使用。
public void removeSyncBarrier(int token) {
// Remove a sync barrier token from the queue.
// If the queue is no longer stalled by a barrier then wake it.
synchronized (this) {
Message prev = null;
Message p = mMessages;
while (p != null && (p.target != null || p.arg1 != token)) {
prev = p;
p = p.next;
}
if (p == null) {
throw new IllegalStateException("The specified message queue synchronization "
+ " barrier token has not been posted or has already been removed.");
}
final boolean needWake;
if (prev != null) {
prev.next = p.next;
needWake = false;
} else {
mMessages = p.next;
needWake = mMessages == null || mMessages.target != null;
}
p.recycleUnchecked();
// If the loop is quitting then it is already awake.
// We can assume mPtr != 0 when mQuitting is false.
if (needWake && !mQuitting) {
nativeWake(mPtr);
}
}
}
当发送系统消息时 会在消息队列中插入一个target为空的message，在取出消息时如果发现了这个消息，就跳过所有的正常消息，返回最近的一个系统消息，然后将这个标记消息从队列中remove。
整个Handler源码学习系列笔记就完结了，当然现在也没有到特别深入的程度，但了解了整套Handler的消息机制后，相信对于源码的阅读能力和编程思路上也有挺大的提高。
网友评论