Handler Message
在Handler中，大致分为3种Message，分别是同步消息，异步消息和同步屏障，他们三者都是Message，只是成员变量有些区别；
同步消息
也就是我一般使用的Message，再通过Handler进行sendMessage到消息队列，前提是构造Handler时候传的构造参数async为false
Handler mHandler = new Handler()
//或者
Handler mHandler = new Handler(false)
通过以上mHandler发送的Message都是同步消息，且Message会与该mHandler绑定，即：
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
//将Handler赋值给Message的target变量
msg.target = this;
//mAsynchronous为false，为同步消息
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
以上就是发送一个同步消息流程
异步消息
根据前面同步消息的发送流程可以知道，只要通过构造参async为true的Handler发送的Message都为异步消息，即：
//构造一个发送处理异步消息的Handler
Handler mHandler = new Handle(true)
所以通过这个mHandler发送的Message，在queueMessage时候，都会把Message的asynchronous设置为true，即异步消息
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
//将Handler赋值给Message的target变量
msg.target = this;
//mAsynchronous为true，为异步消息
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
以上就是发送一个异步消息的流程
同步屏障
虽然没有消息两字，但是同步屏障本质也是Message对象，同步屏障个人觉得可以把它解释为：屏障同步消息的消息，它和前面同步异步消息的最大区别就是，Message.target变量为null，它的作用就是在消息队列(MessageQueue)取出消息的时候，屏蔽掉同步消息，优先获取异步消息的作用
没有同步屏障
假设下图是没有添加同步屏障的消息队列
graph LR
B[同步消息A] --> C[同步消息B]
C[同步消息B] --> D[异步消息A]
那么在loop()循环从MessageQueue取出消息的顺序是
- 同步消息A
- 同步消息B
- 异步消息A
- 睡眠等待消息插入...
有同步屏障
如果在消息队列中插入同步屏障，如下图所示
graph LR
A[同步屏障]-->B[同步消息A]
B[同步消息A] --> C[同步消息B]
C[同步消息B] --> D[异步消息A]
那么在loop()循环从MessageQueue取出消息的顺序是
- 异步消息A
- 睡眠等待消息插入...
此时消息队列变为
graph LR
A[同步屏障]-->B[同步消息A]
B[同步消息A] --> C[同步消息B]
因为同步屏障在获取消息的时候，屏蔽掉同步消息，只取出异步消息，那同步消息怎么办？只有当同步屏障被屏蔽被移除的时候才能获取到同步消息；
通过代码在消息队列添加同步屏障
//在MessageQueue类中，添加同步屏障可以通过postSyncBarrier方法，该方法是被隐藏的，如果要调用的话只能通过反射机制进行调用
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++;
//创建一个Message对象，所以说同步屏障的本质就是Message
//而且在这里看不到Message.target的赋值，所以可以说同步屏障和同步异步消息的区别就是target是否为空
final Message msg = Message.obtain();
msg.markInUse();
msg.when = when;
//记录该同步屏障，后面可以通过token来移除该同步屏障
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;
}
//最后返回token，可以根据这个token移除同步屏障
return token;
}
}
//移除同步屏障
//token就是添加同步屏障时候返回的唯一标示
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);
}
}
}
通过自己代码给消息队列添加同步屏障
//获取当前线程Looper对象的消息队列
MessageQueue queue=handler.getLooper().getQueue();
//通过反射调用
Method method=MessageQueue.class.getDeclaredMethod("postSyncBarrier");
token= (int) method.invoke(queue);
//移除同步屏障
//获取当前线程Looper对象的消息队列
MessageQueue queue=handler.getLooper().getQueue();
Method method=MessageQueue.class.getDeclaredMethod("removeSyncBarrier",int.class);
method.invoke(queue,token);
