1.消息機制簡述
- 準備階段
- 在子線程中調(diào)用Looper.prepare()方法或者在主線程調(diào)用Looper.prepareMainLooper()方法創(chuàng)建當前的Looper對象（主線程中這一步由Android系統(tǒng)在應(yīng)用啟動時完成）
- 在創(chuàng)建Looper對象時會創(chuàng)建一個消息隊列MessageQueue
- Looper通過loop()方法獲取到當前線程的Looper并啟動循環(huán)攒岛，從MessageQueue不斷提取Message，若MessageQueue沒有消息，處于阻塞狀態(tài)柴淘。
- 發(fā)送消息
- 使用當前線程創(chuàng)建的Handler在其他線程通過調(diào)用sendMessage()發(fā)送Message到MessageQueue
- MessageQueue插入新的Message并喚醒阻塞
- 獲取消息
- 重新檢查MessageQueue并獲取新插入的消息Message
- Looper獲取Message后疑苔，通過Message的target即Handler調(diào)用dispatchMessage(Message msg)方法分發(fā)提取到的Message敞恋，然后回收Message并循環(huán)獲取下一個Message
- Handler使用handlerMessage(Message msg)方法處理Message
- 阻塞等待
- MessageQueue沒有Message時箕般，重新進入阻塞狀態(tài)
上段參考：Android Handler消息機制實現(xiàn)原理
1.1 注意事項
- MessageQueue叫做消息隊列梁肿，但是內(nèi)部存儲結(jié)構(gòu)并不是真正的隊列蛤迎，而是采用單鏈表的數(shù)據(jù)結(jié)構(gòu)來存儲消息列表确虱。
2. 準備階段
2.1 prepare
- 調(diào)用Looper.prepare會創(chuàng)建一個Looper對象
- 調(diào)用Looper.prepare時會創(chuàng)建MessageQueue
- 調(diào)用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) {
//創(chuàng)建MessageQueue
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
2.2 loop
- loop方法用于從MessageQueue中取出待處理的消息，會調(diào)用MessageQueue的next方法來獲取消息替裆，如果MessageQueue中沒有消息校辩，Looper就會一直阻塞等待窘问，除非MessageQueue返回null才退出消息的循環(huán)監(jiān)聽。
- 調(diào)用Looper的prepare方法后會創(chuàng)建MessageQueue和Looper宜咒。但需要調(diào)用Looper的loop方法才會開啟消息循環(huán)惠赫，Looper才會開始循環(huán)監(jiān)聽MessageQueue中的消息
- Looper取到消息后，會調(diào)用消息Message所對應(yīng)的Handler的dispatchMessage方法來處理消息荧呐。這樣Handler的dispatchMessage方法就會在Looper所在的線程中執(zhí)行了汉形。
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; // 獲取到當前線程的消息隊列
// 清空遠程調(diào)用端進程的身份，用本地進程的身份代替倍阐，確保此線程的身份是本地進程的身份概疆，并跟蹤該身份令牌
// 這里主要用于保證消息處理是發(fā)生在當前 Looper 所在的線程
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
// 無限循環(huán)
for (;;) {
Message msg = queue.next(); // 從消息隊列中獲取消息，因為next是個無限循環(huán)峰搪，所以loop方法也會阻塞
if (msg == null) {
// 沒有消息則退出循環(huán)岔冀，正常情況下不會退出的，只會阻塞在上一步概耻，直到有消息插入并喚醒返回消息,只有在調(diào)用MessageQueue的quit方法后MessageQueue才會返回null使套，才會退出循環(huán)監(jiān)聽
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 分發(fā)消息
msg.target.dispatchMessage(msg);
} finally {
// 停止跟蹤
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
// 確保在分發(fā)消息的過程中線程的身份沒有改變厌杜，如果改變則發(fā)出警告
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 發(fā)送消息
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) {
...
}
}
- 調(diào)用無參構(gòu)造函數(shù)時，最終會調(diào)用public Handler(Callback callback, boolean async)方法夯尽，不過callback為空瞧壮，async為false
- 通過調(diào)用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將消息發(fā)送到消息隊列
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方法分發(fā)
//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是一個線程內(nèi)部的數(shù)據(jù)存儲類咆槽，通過它可以在指定的線程中存儲數(shù)據(jù)，數(shù)據(jù)存儲以后圈纺，只有在指定線程中可以獲取到存儲的數(shù)據(jù)秦忿，對于其它線程來說無法獲取到數(shù)據(jù)。
示例：分別在主線程蛾娶、子線程1和子線程2中設(shè)置和訪問它的值
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();
結(jié)果：
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內(nèi)部會從各自的線程中取出一個數(shù)組呐萨，然后再從數(shù)組中根據(jù)當前ThreadLocal的索引去查找出對應(yīng)的value值，很顯然莽囤，不同線程中的數(shù)組是不同的谬擦，這就是為什么通過ThreadLocal可以在不同的線程中維護一套數(shù)據(jù)的副本并且彼此互不干擾。
- 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 發(fā)送消息其實就是將 Message 對象插入到消息隊列中惨远，該消息隊列也是使用了鏈表的數(shù)據(jù)結(jié)構(gòu)。
- MessageQueue 在實例化時會傳入 quitAllowed 參數(shù)话肖，用于標識消息隊列是否可以退出北秽，由 ActivityThread 中 Looper 的創(chuàng)建可知，主線程的消息隊列不可以退出最筒。
- MessageQueue 根據(jù)消息的觸發(fā)時間贺氓，將新消息插入到合適的位置，保證所有的消息的時間順序床蜘。
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) {
// 消息隊列為空 或 新消息的觸發(fā)時間為 0 或 新消息的觸發(fā)時間比消息隊列的第一條消息的觸發(fā)時間早
// 將新消息插入到隊列的頭，作為消息隊列的第一條消息邢锯。
msg.next = p;
mMessages = msg;
needWake = mBlocked; // 當阻塞時需要喚醒
} else {
// 將新消息插入到消息隊列中（非隊列頭）
// 當阻塞 且 消息隊列頭是 Barrier 類型的消息（消息隊列中一種特殊的消息扬蕊，可以看作消息屏障，用于攔截同步消息丹擎，放行異步消息） 且 當前消息是異步的 時需要喚醒
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
// 循環(huán)消息隊列尾抑，比較新消息的觸發(fā)時間和隊列中消息的觸發(fā)時間，將新消息插入到合適的位置
for (;;) {
prev = p; // 將前一條消息賦值給 prev
p = p.next; // 將下一條消息賦值給 p
if (p == null || when < p.when) {
// 如果已經(jīng)是消息隊列中的最后一條消息 或 新消息的觸發(fā)時間比較早 則退出循環(huán)
break;
}
if (needWake && p.isAsynchronous()) {
// 需要喚醒 且 下一條消息是異步的 則不需要喚醒
needWake = false;
}
}
// 將新消息插入隊列
msg.next = p;
prev.next = msg;
}
if (needWake) {
// 如果需要喚醒調(diào)用 native 方法喚醒
nativeWake(mPtr);
}
}
return true;
}
從消息隊列中獲取消息，通過MessageQueue里面的next方法實現(xiàn)
Message next() {
// 如果消息隊列退出蓖康，則直接返回
// 正常運行的應(yīng)用程序主線程的消息隊列是不會退出的钓账，一旦退出則應(yīng)用程序就會崩潰
final long ptr = mPtr;
if (ptr == 0) {
return null;
}
int pendingIdleHandlerCount = -1; // 記錄空閑時處理的 IdlerHandler 數(shù)量，可先忽略
int nextPollTimeoutMillis = 0; // native 層使用的變量践磅，設(shè)置的阻塞超時時長
// 開始循環(huán)獲取消息
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
// 調(diào)用 native 方法阻塞，當?shù)却齨extPollTimeoutMillis時長灸异，或者消息隊列被喚醒府适，都會停止阻塞
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
// 嘗試獲取下一條消息，獲取到則返回該消息
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages; // 獲取消息隊列中的第一條消息
if (msg != null && msg.target == null) {
// 如果 msg 為 Barrier 類型的消息肺樟，則攔截所有同步消息檐春，獲取第一個異步消息
// 循環(huán)獲取第一個異步消息
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {
if (now < msg.when) {
// 如果 msg 的觸發(fā)時間還沒有到，設(shè)置阻塞超時時長
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; // 返回該消息，退出循環(huán)
}
} else {
// 如果沒有消息欣舵，則設(shè)置阻塞時長為無限擎鸠，直到被喚醒
nextPollTimeoutMillis = -1;
}
// 如果消息正在退出，則返回 null
// 正常運行的應(yīng)用程序主線程的消息隊列是不會退出的缘圈，一旦退出則應(yīng)用程序就會崩潰
if (mQuitting) {
dispose();
return null;
}
// 第一次循環(huán) 且 （消息隊列為空 或 消息隊列的第一個消息的觸發(fā)時間還沒有到）時劣光，表示處于空閑狀態(tài)
// 獲取到 IdleHandler 數(shù)量
if (pendingIdleHandlerCount < 0
&& (mMessages == null || now < mMessages.when)) {
pendingIdleHandlerCount = mIdleHandlers.size();
}
if (pendingIdleHandlerCount <= 0) {
// 沒有 IdleHandler 需要運行，循環(huán)并等待
mBlocked = true; // 設(shè)置阻塞狀態(tài)為 true
continue;
}
if (mPendingIdleHandlers == null) {
mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
}
mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
}
// 運行 IdleHandler糟把，只有第一次循環(huán)時才會運行
for (int i = 0; i < pendingIdleHandlerCount; i++) {
final IdleHandler idler = mPendingIdleHandlers[i];
mPendingIdleHandlers[i] = null; // 釋放 IdleHandler 的引用
boolean keep = false;
try {
keep = idler.queueIdle(); // 執(zhí)行 IdleHandler 的方法
} catch (Throwable t) {
Log.wtf(TAG, "IdleHandler threw exception", t);
}
if (!keep) {
synchronized (this) {
mIdleHandlers.remove(idler); // 移除 IdleHandler
}
}
}
// 重置 IdleHandler 的數(shù)量為 0绢涡，確保不會重復(fù)運行
// pendingIdleHandlerCount 置為 0 后，上面可以通過 pendingIdleHandlerCount < 0 判斷是否是第一次循環(huán)糊饱，不是第一次循環(huán)則 pendingIdleHandlerCount 的值不會變垂寥，始終為 0。
pendingIdleHandlerCount = 0;
// 在執(zhí)行 IdleHandler 后另锋，可能有新的消息插入或消息隊列中的消息到了觸發(fā)時間滞项，所以將 nextPollTimeoutMillis 置為 0，表示不需要阻塞夭坪，重新檢查消息隊列文判。
nextPollTimeoutMillis = 0;
}
}
總結(jié)
消息處理順序
- 準備
（1）如果在子線程里接收并處理消息，則需要調(diào)用Looper.prepare()方法室梅；如果在主線程里接收并處理消息戏仓，則不用自己調(diào)用prepare方法，因為在初始化Activity時亡鼠，系統(tǒng)已經(jīng)初始化了一個Looper赏殃，Looper.prepareMainLooper()
（2）調(diào)用Looper.loop()方法獲得當前線程的Looper對象，并循環(huán)從MessageQueue中獲取消息间涵，如果消息為空仁热，則阻塞 - 發(fā)送消息
（1）創(chuàng)建并初始化Handler對象，在需要發(fā)送消息的線程里調(diào)用handler.sendMessage(msg);
（2）通過handler.sendMessage(msg)發(fā)送的消息最終會調(diào)用enqueueMessage將消息插入到消息隊列中 - 獲取消息
（1）通過Looper的loop方法循環(huán)獲取MessageQueue里的消息勾哩，如果消息隊列里的消息為空抗蠢，則阻塞，否則取出消息
（2）獲取到MessageQueue里面的消息后思劳，通過handler的dispatchMessage來分發(fā)消息
（3）然后Handler通過handlerMessage方法來處理得到的消息 - 所有消息處理完后進入阻塞狀態(tài)
參考文獻：
http://www.reibang.com/p/3b8c2dbf1124
https://yq.aliyun.com/articles/649873
https://blog.csdn.net/singwhatiwanna/article/details/48350919
