這節主要介紹Message都有哪些類型以及作用。（以下分析都是基于android 12代碼）
同步Message
同步Message自不必多說，默認創建的Message都是同步的。
同步屏障Message
同步屏障Message是什么？
同步屏障Message可以這樣理解：創建這種類型的Message并且把它放入MessageQueue的mMessages鏈表中，當執行到這種類型的Message后，它會阻止它后面的所有同步Message執行（即使同步Message到了應該執行的時間），只允許它后面的異步Message執行。
執行同步屏障Message的代碼在next方法中
MessageQueue#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;
//msg.target == null 代表是同步屏障Message
if (msg != null && msg.target == null) {
// Stalled by a barrier. Find the next asynchronous message in the queue.
//下面的邏輯是從鏈表中依次去查詢是異步類型的Message，找到則執行后面邏輯，否則不執行任何同步Message
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
//如果msg存在則執行
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代表需要等待MessageQueue中放入Message，否則一直等待
nextPollTimeoutMillis = -1;
}
省略代碼......
}
省略代碼......
}
}
因此同步屏障Message是需要和異步Message配合才有意義。
同步屏障Message的使用
創建同步屏障Message
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) {
//創建一個token，因為可能存在創建多個syncBarrier的情況，因此token就代表當前創建的syncBarrier
final int token = mNextBarrierToken++;
final Message msg = Message.obtain();
msg.markInUse();
msg.when = when;
//token賦值給msg的arg1
msg.arg1 = token;
Message prev = null;
Message p = mMessages;
//根據when值 找到syncBarrier需要存放的位置
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
return token;
}
}
調用postSyncBarrier方法就可以創建一個同步屏障Message，并且返回一個token，這個token需要保存，因為在移除的時候需要用到。同步屏障Message和普通的Message沒啥區別，除了Message的target屬性為null。因此如果Message的target為null就可以斷定這個Message是同步屏障Message。
移除同步屏障Message
因為這種類型的Message需要創建者移除，不移除那就會導致所有的同步Message沒法執行。移除方法如下：
MessageQueue#removeSyncBarrier
//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;
//根據token和target==null來查找同步屏障Message
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;
}
//把Message回收
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);
}
}
}
如上調用removeSyncBarrier方法參數為創建時候返回的token就可以把同步屏障Message移除。
異步Message
異步Message：這里的異步容易讓人產生誤解，總以為這種類型的Message是可以并行執行多個的意思，其實不是。它和同步Message，同步屏障Message一樣也都是按照Message的when屬性值的大小在鏈表中排列的。
創建異步的方法特別簡單，只需要調用Message的setAsynchronous方法即可。
異步Message需要和同步屏障Message結合使用，它倆誰也離不了誰。如果沒有同步屏障Message，那異步Message和同步Message沒有任何區別。
異步Message和同步屏障Message的組合主要是解決這類問題：比如當前有一些Message，它們的優先級要高于其他的Message，必須先執行完這批Message后才能執行優先級低的Message。其中一個應用場景就是在繪制view的時候用到，如下部分代碼：
ViewRootImpl#scheduleTraversals
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
void scheduleTraversals() {
if (!mTraversalScheduled) {
mTraversalScheduled = true;
//創建同步屏障Message
mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
mChoreographer.postCallback(
Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
notifyRendererOfFramePending();
pokeDrawLockIfNeeded();
}
}
上面代碼在繪制之前創建了同步屏障Message，這樣把當前所有可執行的同步Message都給阻止掉，因為繪制的優先級最高，假如讓一些同步Message執行，若它們耗時，這完全會影響整個繪制流程，你說是繪制重要還是啥重要，整個界面都一片空白了，那肯定會被用戶罵的。
Choreographer#onVsync
public void onVsync(long timestampNanos, long physicalDisplayId, int frame,
VsyncEventData vsyncEventData) {
try {
省略代碼......
Message msg = Message.obtain(mHandler, this);
//設置Message為異步Message
msg.setAsynchronous(true);
mHandler.sendMessageAtTime(msg, timestampNanos / TimeUtils.NANOS_PER_MS);
} finally {
Trace.traceEnd(Trace.TRACE_TAG_VIEW);
}
}
在Choreographer的onVsync方法中，收到vsync信號后，為了讓繪制工作能高優先級執行，把Message設置為異步，因為ViewRootImpl的scheduleTraversals方法中已經加入同步屏障Message了，所以高優先級執行繪制操作。
idle ”Message“
idle ”Message“：它其實不是一個Message，可以把它看成一個偽Message，在MessageQueue的next方法進行第一次循環的時候，嘗試去執行所有的idle ”Message“。
相應的代碼如下：
MessageQueue#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;
}
//pendingIdleHandlerCount賦值為-1 代表只有第一次循環的時候才去執行idle Message
int pendingIdleHandlerCount = -1; // -1 only during first iteration
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
省略代碼......
// 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.
//進入循環之前，給pendingIdleHandlerCount賦值了-1,因此pendingIdleHandlerCount< 0并且沒有可執行的Message時候，開始準備執行idle Message
if (pendingIdleHandlerCount < 0
&& (mMessages == null || now < mMessages.when)) {
//mIdleHandlers存放了所有的idle Message
pendingIdleHandlerCount = mIdleHandlers.size();
}
//沒有可執行的idle Message，則不往下面執行
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.
//依次循環執行idle Message
for (int i = 0; i < pendingIdleHandlerCount; i++) {
//拿出IdleHandler
final IdleHandler idler = mPendingIdleHandlers[i];
mPendingIdleHandlers[i] = null; // release the reference to the handler
boolean keep = false;
try {
//調用idler的queueIdle方法，該方法會返回一個boolean值，代表是否移除：false則需要移除；否則不用移除
keep = idler.queueIdle();
} catch (Throwable t) {
Log.wtf(TAG, "IdleHandler threw exception", t);
}
if (!keep) {
synchronized (this) {
//需要移除，則從mIdleHandlers移除這個idler
mIdleHandlers.remove(idler);
}
}
}
// Reset the idle handler count to 0 so we do not run them again.
//把pendingIdleHandlerCount賦值為0,代表下一次就不用執行idle Message了
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;
}
}
它對應的類如下：(其實是一個接口)
MessageQueue#IdleHandler
public static interface IdleHandler {
/**
* Called when the message queue has run out of messages and will now
* wait for more. Return true to keep your idle handler active, false
* to have it removed. This may be called if there are still messages
* pending in the queue, but they are all scheduled to be dispatched
* after the current time.
*/
boolean queueIdle();
}
添加一個idle ”Message“的方法如下：
MessageQueue#addIdleHandler
public void addIdleHandler(@NonNull IdleHandler handler) {
if (handler == null) {
throw new NullPointerException("Can't add a null IdleHandler");
}
synchronized (this) {
mIdleHandlers.add(handler);
}
}
總結
到此Message的類型就介紹完畢，每種Message都有自己適用的場景，大家可以根據需要來使用相應的Message
