一润讥、常見使用場景
消息機制中主要用于多線程的通訊，在 Android 開發(fā)中最常見的使用場景是：在子線程做耗時操作，操作完成后需要在主線程更新 UI（子線程不能直接修改 UI）。這時就需要用到消息機制來完成子線程和主線程的通訊茎截。
如以下代碼片段所示：
public class MainActivity extends AppCompatActivity {
private TextView tvText;
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
tvText.setText(msg.obj.toString());
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
tvText = (TextView) findViewById(R.id.tv_text);
new Thread() {
@Override
public void run() {
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Message msg = Message.obtain();
msg.obj = Thread.currentThread().getName();
mHandler.sendMessage(msg);
}
}.start();
}
}
子線程阻塞 10 秒后發(fā)送消息更新 TextView，TextView 顯示來源的線程名赶盔。
這里有兩個限制：
不能讓阻塞發(fā)生在主線程企锌，否則會發(fā)生 ANR
不能在子線程更新 TextView。
所以只能在子線程阻塞 10 秒于未，然后通過 Handler 發(fā)送消息撕攒，Handler 處理獲取到的消息并在主線程更新 TextView。
二烘浦、消息機制分析
1. 準備階段
1.1 Handler 構(gòu)造方法
private Handler mHandler = new Handler() {
...
};
查看 Handler 的源碼：
...
public Handler() {
this(null, false);
}
...
/**
* @hide 該構(gòu)造方法是隱藏的抖坪，無法直接調(diào)用
*/
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 的構(gòu)造方法需要傳入兩個參數(shù)，第一個參數(shù)是 Handler.Callback 接口的實現(xiàn)闷叉，第二個參數(shù)是標志傳遞的 Message 是否是異步擦俐。
構(gòu)造方法內(nèi)部首先會檢查 Handler 的使用是否可能存在內(nèi)存泄漏的問題，如果存在會發(fā)出一個警告：
所以在使用 Handler 的時候一般聲明為靜態(tài)內(nèi)部類或使用弱引用的方式握侧。
接著會調(diào)用 Looper.myLooper() 獲取到 Looper 對象蚯瞧，并判斷該 Looper 對象是否為 null，如果為 null 則拋出異常品擎；如果不為 null 則進行相應的賦值操作埋合。由此可知 Looper.myLooper() 方法并不會構(gòu)造一個 Looper 對象，而是從某個地方獲取到一個 Looper 對象萄传。
所以甚颂，在創(chuàng)建 Handler 對象時必須先創(chuàng)建 Looper 對象。
1.2 Looper 對象的創(chuàng)建
下面查看 Looper 源碼：
...
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
...
/** Initialize the current thread as a looper.
* This gives you a chance to create handlers that then reference
* this looper, before actually starting the loop. Be sure to call
* {@link #loop()} after calling this method, and end it by calling
* {@link #quit()}.
*/
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");
}
sThreadLocal.set(new Looper(quitAllowed));
}
/**
* Initialize the current thread as a looper, marking it as an
* application's main looper. The main looper for your application
* is created by the Android environment, so you should never need
* to call this function yourself. See also: {@link #prepare()}
*/
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
...
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
...
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
...
從 Looper 的源碼可知盲再，Looper 類中對外部提供兩個方法用于創(chuàng)建 Looper 對象：prepare() 和 prepareMainLooper()西设，并將創(chuàng)建的 Looper 對象保存到 sThreadLocal 中。myLooper() 方法獲取 Looper 對象也是從 sThreadLocal 中獲取答朋。
sThreadLocal 是一個ThreadLocal 對象贷揽，ThreadLocal 用于提供線程局部變量，在多線程環(huán)境可以保證各個線程里的變量獨立于其它線程里的變量梦碗。也就是說 ThreadLocal 可以為每個線程創(chuàng)建一個【單獨的變量副本】禽绪，相當于一個線程的 private static 類型變量。
在 Looper 的真正創(chuàng)建對象方法 prepare(boolean quitAllowed) 中洪规，會先判斷當前線程是否已經(jīng)有 Looper 對象印屁，沒有時才可以創(chuàng)建并保存到當前線程中，每個線程只允許有一個 Looper斩例。
上面的示例代碼中是在主線程中實例化 Handler 的雄人，但是并沒有調(diào)用 Looper 的創(chuàng)建方法，而且也沒有拋出異常，說明主線程中是有 Looper 對象的础钠。
那么主線程中的 Lopper 對象是從哪里來的呢恰力？
在 Looper 的 prepareMainLooper() 方法注釋中可以看到這樣一句話：
The main looper for your application is created by the Android environment, so you should never need to call this function yourself.
意思是：應用程序的主 Looper 由 Android 環(huán)境創(chuàng)建，不應該自己調(diào)用該方法旗吁。
由此可知踩萎，在 Android 系統(tǒng)源碼中應該會調(diào)用該方法，通過查找該方法的使用發(fā)現(xiàn)很钓，在 ActivityThread 類的 main 方法中調(diào)用了 Looper.prepareMainLooper()：
public static void main(String[] args) {
...
Looper.prepareMainLooper();
...
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
所以在應用程序啟動時就已經(jīng)為主線程創(chuàng)建了一個 Looper 對象香府。
2. 發(fā)送消息
繼續(xù)分析示例代碼，在子線程阻塞結(jié)束后會創(chuàng)建一個 Message 對象码倦，然后使用 Handler 發(fā)送該 Message 對象企孩。
...
Message msg = Message.obtain();
msg.obj = Thread.currentThread().getName();
mHandler.sendMessage(msg);
...
2.1 創(chuàng)建 Message 對象
調(diào)用 Message 的 obtain() 方法創(chuàng)建 Message 對象。
查看 Message 的源碼：
...
public static Message obtain() {
synchronized (sPoolSync) {
if (sPool != null) {
Message m = sPool;
sPool = m.next;
m.next = null;
m.flags = 0; // clear in-use flag
sPoolSize--;
return m;
}
}
return new Message();
}
...
public Message() {
}
...
Message 是消息機制中消息的載體叹洲，為了優(yōu)化性能柠硕，避免重復 Message 的創(chuàng)建，Message 使用了消息池機制运提，當調(diào)用 obtain() 方法時，會先嘗試從消息池中獲取一個 Message 對象闻葵，消息池中沒有時才創(chuàng)建新的對象民泵；Message 對象使用完后會重新回收到消息池中。Message 的消息池使用了鏈表的數(shù)據(jù)結(jié)構(gòu)槽畔，Message 類本身時支持鏈表結(jié)構(gòu)的栈妆。
所以在創(chuàng)建 Message 對象時不要直接使用構(gòu)造方法。
創(chuàng)建好 Message 對象后厢钧，可以給 Message 的一些屬性賦值鳞尔，用于描述該消息或攜帶數(shù)據(jù)。
2.2 Handler 發(fā)送消息
調(diào)用 Handler 的 sendMessage(Message msg) 方法發(fā)送消息早直。
通過查看 Handler 的源碼可知寥假，在 Handler 中有許多發(fā)送消息的方法，所有的發(fā)送消息方法最終都會調(diào)用 enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) 方法霞扬。
...
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);
}
...
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);
}
首先給 Message 的 target 屬性賦值糕韧，即當前的 Handler；然后根據(jù) Handler 的 mAsynchronous 值設置該 Message 是否是異步的喻圃，mAsynchronous 的值在 Handler 實例化時被賦值萤彩；最后調(diào)用 MessageQueue 的 enqueueMessage(Message msg, long when) 方法。
可以看出在 Handler 中也只是對 Message 對象的屬性進行了相關賦值操作斧拍，最終是調(diào)用了 MessageQueue 的 enqueueMessage(Message msg, long when) 方法雀扶。
2.3 MessageQueue
enqueueMessage() 方法中的 MessageQueue 對象來自于 Handler 的 mQueue 屬性：
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);
}
而 mQueue 屬性在 Handler 實例化時賦值的：
public Handler(Callback callback, boolean async) {
...
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;
}
mQueue 是 Looper 中的 MessageQueue 對象，在 Looper 創(chuàng)建時被實例化：
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
查看 MessageQueue 的構(gòu)造方法：
MessageQueue(boolean quitAllowed) {
mQuitAllowed = quitAllowed;
mPtr = nativeInit();
}
MessageQueue 是消息隊列肆汹，Handler 發(fā)送消息其實就是將 Message 對象插入到消息隊列中愚墓，該消息隊列也是使用了鏈表的數(shù)據(jù)結(jié)構(gòu)予权。同時 Message 也是消息機制中 Java 層和 native 層的紐帶，這里暫且不關心 native 層相關實現(xiàn)转绷。
MessageQueue 在實例化時會傳入 quitAllowed 參數(shù)伟件，用于標識消息隊列是否可以退出，由 ActivityThread 中 Looper 的創(chuàng)建可知议经，主線程的消息隊列不可以退出斧账。
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 根據(jù)消息的觸發(fā)時間闪萄，將新消息插入到合適的位置，保證所有的消息的時間順序奇颠。
3. 處理消息
消息的發(fā)送已經(jīng)分析過了败去，下面需要分析的是如何獲取消息并處理消息，繼續(xù)分析實例代碼：
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
tvText.setText(msg.obj.toString());
}
};
從示例代碼中可以看到 Handler 的 handleMessage(Message msg) 負責處理消息烈拒，但是并沒有看到是如何獲取到消息的圆裕。需要在 Handler 的源碼中查找是在哪里調(diào)用 handleMessage(Message msg) 方法的。
通過在 Handler 的源碼中查找荆几，發(fā)現(xiàn)是在 dispatchMessage(Message msg) 方法中調(diào)用 handleMessage(Message msg) 的吓妆。
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
3.1 Looper 循環(huán)從消息隊列中取消息
dispatchMessage(Message msg) 方法中筝闹，根據(jù)不同的情況調(diào)用不同的消息處理方法级历。繼續(xù)向上查找 dispatchMessage(Message msg) 的引用，發(fā)現(xiàn)是在 Looper 的 loop() 方法中調(diào)用的痕囱，而在之前分析 Looper 的創(chuàng)建時焊傅，可以知道在 ActivityThread 的 main 方法中有調(diào)用 loop() 方法剂陡。
public static void main(String[] args) {
...
Looper.prepareMainLooper();
...
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
下面分析 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(); // 從消息隊列中獲取消息，可能會阻塞
if (msg == null) {
// 沒有消息則退出循環(huá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 放入消息池
}
}
在 loop() 方法中，會不停的循環(huán)以下操作：
調(diào)用當前線程的 MessageQueue 對象的 next() 方法獲取消息
通過消息的target屑墨，即 Handler 分發(fā)消息
回收消息躁锁，將分發(fā)后的消息放入消息池
3.1 從消息隊列中獲取消息
在 loop() 方法中獲取消息時有可能會阻塞，來看下 MessageQueue 的 next() 方法的實現(xiàn)：
Message next() {
// 如果消息隊列退出卵史，則直接返回
// 正常運行的應用程序主線程的消息隊列是不會退出的战转，一旦退出則應用程序就會崩潰
final long ptr = mPtr;
if (ptr == 0) {
return null;
}
int pendingIdleHandlerCount = -1; // 記錄空閑時處理的 IdlerHandler 數(shù)量，可先忽略
int nextPollTimeoutMillis = 0; // native 層使用的變量以躯，設置的阻塞超時時長
// 開始循環(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ā)時間還沒有到命雀，設置阻塞超時時長
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 {
// 如果沒有消息易核，則設置阻塞時長為無限，直到被喚醒
nextPollTimeoutMillis = -1;
}
// 如果消息正在退出浪默，則返回 null
// 正常運行的應用程序主線程的消息隊列是不會退出的牡直，一旦退出則應用程序就會崩潰
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; // 設置阻塞狀態(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，確保不會重復運行
// pendingIdleHandlerCount 置為 0 后阔加，上面可以通過 pendingIdleHandlerCount < 0 判斷是否是第一次循環(huán)饵史，不是第一次循環(huán)則 pendingIdleHandlerCount 的值不會變，始終為 0。
pendingIdleHandlerCount = 0;
// 在執(zhí)行 IdleHandler 后胳喷，可能有新的消息插入或消息隊列中的消息到了觸發(fā)時間湃番，所以將 nextPollTimeoutMillis 置為 0，表示不需要阻塞吭露，重新檢查消息隊列吠撮。
nextPollTimeoutMillis = 0;
}
}
nativePollOnce(ptr, nextPollTimeoutMillis) 是調(diào)用 native 層的方法執(zhí)行阻塞操作，其中 nextPollTimeoutMillis 表示阻塞超時時長：
nextPollTimeoutMillis = 0 則不阻塞
nextPollTimeoutMillis = -1 則一直阻塞讲竿，除非消息隊列被喚醒
三泥兰、總結(jié)
消息機制的流程如下：
- 準備階段：
在子線程調(diào)用 Looper.prepare() 方法或 在主線程調(diào)用 Lopper.prepareMainLooper() 方法創(chuàng)建當前線程的 Looper 對象（主線程中這一步由 Android 系統(tǒng)在應用啟動時完成）
在創(chuàng)建 Looper 對象時會創(chuàng)建一個消息隊列 MessageQueue
Looper 通過 loop() 方法獲取到當前線程的 Looper 并啟動循環(huán)，從 MessageQueue 不斷提取 Message戴卜，若 MessageQueue 沒有消息逾条，處于阻塞狀態(tài)
- 發(fā)送消息
使用當前線程創(chuàng)建的 Handler 在其它線程通過 sendMessage() 發(fā)送 Message 到 MessageQueue
MessageQueue 插入新 Message 并喚醒阻塞
- 獲取消息
重新檢查 MessageQueue 獲取新插入的 Message
Looper 獲取到 Message 后，通過 Message 的 target 即 Handler 調(diào)用 dispatchMessage(Message msg) 方法分發(fā)提取到的 Message投剥，然后回收 Message 并繼續(xù)循環(huán)獲取下一個 Message
Handler 使用 handlerMessage(Message msg) 方法處理 Message
- 阻塞等待
- MessageQueue 沒有 Message 時师脂，重新進入阻塞狀態(tài)
