編輯：關於Android編程
很多程序猿(媛)都對消息處理機制做過分析，大家都基本了解了MessageQueue、Handler、Looper之間相互之間怎麼協同工作，但是具體到消息是如何傳遞，取出，如何處理的過程並不是那麼清晰，本人曾經也是如此。為了拿下這個城池，特此寫下此文深入分析其中的每一處是如何工作。
Android的應用程序是通過消息機制來驅動的，深入理解Android應用程序的消息機制就顯得尤為重要，這個消息處理機制主要是圍繞消息隊列來實現的。
在Android應用程序中，可以在一個線程啟動時在內部創建一個消息隊列，然後再進入到一個無限循環的模式之中，不斷地檢查這個消息隊列是否有新的消息需要進行處理。如果需要處理，那麼該線程就會從這個消息隊列中取出消息從而進行處理，如果沒有消息需要處理，則線程處於等待狀態。
在整個消息機制處理過程中會涉及到幾個類，如ThreadLocal、Looper、Message、MessageQueue、Handler。
在分析消息機制的實現原理之前先熟悉一下相關類的原理。
為了在一個線程中都有自己的共享變量，JDK中提供了ThreadLocal這個類。ThreadLocal是一個線程內部存儲數據的泛型類，可以類比喻全局存放數據的盒子，盒子裡可以存儲每個線程的私有數據。
使用場景：
1、變量的作用域只限定在線程中。
2、在一些復雜邏輯的情況下需要傳遞對象，例如監聽器的傳遞。
首先以一個例程來說明使用ThreadLocal，線程之間存儲的數據的作用域只限定在線程以內。
public class ThreadLocalTest {
private static ThreadLocal mThreadLocal = new ThreadLocal<>();
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
mThreadLocal.set(false);
System.out.println(Thread.currentThread().getName() + " value: " + mThreadLocal.get());
}
}, "Thread--1").start();
new Thread(new Runnable() {
@Override
public void run() {
mThreadLocal.set(true);
System.out.println(Thread.currentThread().getName() + " value: " + mThreadLocal.get());
}
}, "Thread--2").start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " value: " + mThreadLocal.get());
}
}, "Thread--3").start();
}
}
運行的結果是：
Thread–1 value: false
Thread–2 value: true
Thread–3 value: null
由結果可以說明各線程之間存儲的值是相互不影響，下面深入ThreadLocal源代碼來分析ThreadLocal內部是如何實現的。
先關注一下set()方法
public void set(T value) {
Thread currentThread = Thread.currentThread();
Values values = values(currentThread);
if (values == null) {
values = initializeValues(currentThread);
}
values.put(this, value);
}
在set()方法中，首先獲取調用該方法的線程對象，而values()方法主要是獲取Thread中的localValues對象值，如果這個對象為null，則使用initializeValues()方法來初始化Thread中的localValues值。初始化values值之後，將value值保存到該線程中的localValues值中(values.put(this, value)方法)。在此處已經很明了，每一個線程保存的值其實都是保存到對應線程內部的Values中，即localValues對象中。
而Values又是什麼鬼？調用put()方法又是如何保存對象數據的呢？
Values是ThreadLocal中的一個靜態內部類，ThreadLocal的值主要是存儲到Values中的table數組中。
在創建Values對象時，構造函數會初始化table數組的大小，源代碼中的長度大小為16，因為是需要存儲鍵值對，因為初始化的時候擴展了其大小為32，所以這裡的長度大小必須為偶數。
下面看下put()方法：
void put(ThreadLocal key, Object value) {
cleanUp();
// Keep track of first tombstone. That's where we want to go back
// and add an entry if necessary.
int firstTombstone = -1;
for (int index = key.hash & mask;; index = next(index)) {
Object k = table[index];
if (k == key.reference) {
// Replace existing entry.
table[index + 1] = value;
return;
}
if (k == null) {
if (firstTombstone == -1) {
// Fill in null slot.
table[index] = key.reference;
table[index + 1] = value;
size++;
return;
}
// Go back and replace first tombstone.
table[firstTombstone] = key.reference;
table[firstTombstone + 1] = value;
tombstones--;
size++;
return;
}
// Remember first tombstone.
if (firstTombstone == -1 && k == TOMBSTONE) {
firstTombstone = index;
}
}
}
存儲過程中將ThreadLocal值存儲在table[index]下，而對應的value值存儲在下一個table[index + 1]值中，這樣就形成了鍵值鍵值…的存儲規律。
分析完set()方法後，我們再來看ThreadLocal的get()方法是如何實現的？
public T get() {
// Optimized for the fast path.
Thread currentThread = Thread.currentThread();
Values values = values(currentThread);
if (values != null) {
Object[] table = values.table;
int index = hash & values.mask;
if (this.reference == table[index]) {
return (T) table[index + 1];
}
} else {
values = initializeValues(currentThread);
}
return (T) values.getAfterMiss(this);
}
獲取當前線程的localValues值(即為values)，如果values值不為null，取出Values之中的table數組，在數組中找出ThreadLocal對應存儲的數據，返回其類型轉換後的值；如果values值為null，則初始化values值，之後調用 (T) values.getAfterMiss(this);在此不詳細介紹該方法，主要是返回null。這也對應了之前例程第三個線程沒有對ThreadLocal設值後打印出來的值是null不謀而合了。
以上的set()和get()方法中所操作的對象都是當前線程對象中的localValues數組，而數組中保存了ThreadLocal對象以及存儲的數據。
Looper在Android消息機制裡的作用就要是創建消息隊列，並不斷的從消息隊列中查看是否有消息需要處理，有消息則取出給Handler來處理，沒有消息則一直處於阻塞狀態。在Looper中有兩個特別重要的靜態方法，一個是prepare(),另一個是loop()。
1、先看prepare()方法，這個方法主要是創建Looper對象。
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));
}
前面分析過ThreadLocal，sThreadLocal就是一個存儲Looper的ThreadLocal對象，如果在sThreadLocal中沒有取到Looper對象，那麼就會新創建一個Looper對象，並且會將這個對象存儲到sThreadLocal對象中去。
下面看下Looper的構造函數是怎樣實現的。
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
在構造函數中，創建了一個新的消息隊列mQueue，並且獲取了當前線程的對象。
pepare()是一般線程所使用的方法，而在Android英語程序的主線程（UI線程）中要創建Looper對象，則會使用prepareMainLooper()方法。
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
因為這個線程一直存在，那麼整個消息處理機制（其中的消息隊列不能退出）都需要伴隨整個線程周期，那麼在初始化的時候prepare()方法中傳入的參數是false。在初始化Looper對象後，再對Looper對象中的屬性sMainLooper賦值，這裡是從sThreadLocal中取出的值。
2、創建Looper對象之後，接著就是需要對所創建的消息隊列進行循環，那麼就需要啟動循環操作，調用Looper.loop()方法就能啟動消息循環了。下面分析loop()方法的實現原：
public static void loop() {
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;
// Make sure the identity of this thread is that of the local process,
// and keep track of what that identity token actually is.? Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
// This must be in a local variable, in case a UI event sets the logger
Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
msg.target.dispatchMessage(msg);
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
// Make sure that during the course of dispatching the
// identity of the thread wasn't corrupted.
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();
}
}
首先獲取Looper對象，這裡是從sThreadLocal獲取的，對應的線程存放了自己內部的Looper對象。如果獲取的Looper對象為null，則不會執行後續消息循環操作，如果不為空，則可以獲取到looper對象中的消息隊列，之前已經說明消息隊列是在Looper的構造函數中初始化的，那麼在此就可以獲取到了mQueue。for是一個無限循環的操作，在調用MessageQueue的next方法，其作用是從消息隊列中取出消息，在源碼中有注釋在此處可能會阻住，具體實現原理將在下一節中說明。如果消息隊列中沒有消息則退出循環操作。此循環中的核心代碼msg.target.dispatchMessage(msg)，target是一個Handler對象，這個對象就是發送消息的那個Handler對象，handler對象分發消息，在handler的dispatchMessage方法中會執行內部的處理消息的方法handleMessage()。消息分發完之後recycleUnchecked()執行消息的回收工作,將消息存入回收的消息池當中。
整個消息的循環，處理分析過程也在此告一段落。
Google團隊在設計Looper的時候還考慮到了如果不使用Looper時，可以選擇退出的方法，這裡有兩種方式：一種是直接調用quite()方法退出；另一種是調用quiteSafely()方法等待消息處理完成後安全退出。
為什麼這樣設計，因為剛才我們在分析循環那一部分時，在消息隊列中取消息時會一直會處於阻住（該線程就會一直處於等待狀態）。這裡都是調用了消息隊列中的方法，在後續分析MessageQueue的章節中會詳細分析其實現原理。
Android應用程序是事件驅動的，每個事件都會轉化成一個可以序列化的系統消息。而這個消息（Message）中包含了兩個額外的整型數據字段和一個額外的對象字段。Message是一個可序列化的對象，what是Message的標識，如果需要存儲的數據是int型的，那麼可以存儲到arg1，arg2，而需要存儲序列化的對象時，可將數據存儲到一個Bundle對象（data）中。
在創建一個Message對象時，有兩種方式：一種是new Message()，另外一種是Message.obtain()方法。雖然消息的構造函數是公共的，但最好的方法是調用Message.obtain()或Handler.obtainMessage()方法，從對象池中獲取。
下面主要分析第二種創建Message對象的方式：
obtain()方法采用了享元模式，這樣便於更少的創建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();
}
sPoolSync是一個同步對象鎖，進入同步方法後，sPool是一個共享對象池，如果sPool為null，則會直接創建一個Message對象。如果sPool不為null，則會從回收的對象池中獲取消息對象，而對象池重新賦值為m.next。如果之前對象池的next不為null，則為為對應的值，否則為null，如果為null，則對象池的值就為null。而當前消息對象的next為賦值為null，並將當前消息對象標志flag為未使用，消息池中的長度減少1。其實這裡的整個過程就是從對象池中將一個Message中取出，脫離對象池。
Message鏈表如下圖所示：
![\](https://www.android5.online/Android/UploadFiles_5356/201702/2017022311555788.jpg "\")
下面分析如果從對象池中獲取一個Message對象，上圖是一個消息池，將m賦值為sPool，之後將消息池重新賦值為m.next，此時的消息池為下圖所示。<喎?/kf/ware/vc/" target="_blank" class="keylink">vcD4NCjxwPjxpbWcgYWx0PQ=="" src="/uploadfile/Collfiles/20160519/20160519092931299.jpg" title="\" />
那麼第一個Message就脫離sPool了，但是它的next值是一個鏈表，從而後面繼續對m.next賦值為null，這樣就將Message對象從對象池中完全取出來了，而消息池sPool的長度確實減少了一個長度值。
其他的obtain方法，只是將傳入的參數賦值到Message對象所對應的屬性對象。
下面分析recycle()方法。
public void recycle() {
if (isInUse()) {
if (gCheckRecycle) {
throw new IllegalStateException("This message cannot be recycled because it " + "is still in use.");
}
return;
}
recycleUnchecked();
}
當Message調用回收的方法時，首先會判斷該Message是否在使用，
/*package*/ boolean isInUse() {
return ((flags & FLAG_IN_USE) == FLAG_IN_USE);
}
當flag值為1，就表示該消息在使用中，那麼不會執行回收的後續操作。否則就執行recycleUnchecked方法。
void recycleUnchecked() {
// Mark the message as in use while it remains in the recycled object pool.
// Clear out all other details.
flags = FLAG_IN_USE;
what = 0;
arg1 = 0;
arg2 = 0;
obj = null;
replyTo = null;
sendingUid = -1;
when = 0;
target = null;
callback = null;
data = null;
synchronized (sPoolSync) {
if (sPoolSize < MAX_POOL_SIZE) {
next = sPool;
sPool = this;
sPoolSize++;
}
}
}
在回收過程中，依然認為該message在使用，所以flag標志為1，但是其它的屬性值都賦值為初始值。在同步方法鎖內的代碼塊，如果當前消息池的長度小於池的最大長度時，則可以將該回收的消息存到消息池中。next 賦值為之前的消息池，而現在的消息池對象指向當前消息，從而將當前消息鏈接到消息鏈表的首部中。
關於Message中的序列化的方法，以及toString方法就不一一介紹了。
Android應用程序的消息機制都是圍繞著消息隊列來展開工作的，那麼掌握好MessageQueue的實現原理就顯得尤為重要了。MessageQueue內部的消息存儲的數據結構是采用的單鏈表形式，而不是隊列。因為添加消息時，處理消息可以設定相應的時間，那麼就需要對添加的消息進行排序，而單鏈表的插入和刪除的開銷時間為線性關系，也比較適合這個場景。在MessageQueue中比較重要的兩個方法是，enqueueMessage()插入消息，next()取出消息並在消息隊列中刪除。
之前我們在分析Looper時已經知道在調用Looper.prepare()方法時創建了消息隊列，在MessageQueue構造方法裡，初始化了是否允許消息隊列退出的標志，另外還初始化了一個C++層的NativeMessageQueue對象，並且mPtr值就是該對象的地址值。
在NativeMessageQueue中源代碼的構造函數如下
NativeMessageQueue::NativeMessageQueue() :
mPollEnv(NULL), mPollObj(NULL), mExceptionObj(NULL) {
mLooper = Looper::getForThread();
if (mLooper == NULL) {
mLooper = new Looper(false);
Looper::setForThread(mLooper);
}
}
在初始化NativeMessageQueue時會創建C++層的mLooper對象，getForThread()判斷當前線程是否創建mLooper的對象，如果沒有創建則會創建mLooper對象，創建後的對象會通過setForThread()方法來關聯當前線程，後續實現通過管道來處理，我們這不再進一步分析，這個可參考《Android源代碼情景分析》一書。
下面分析插入和取出(刪除)消息的方法。
1、插入操作
boolean enqueueMessage(Message msg, long when) {
if (msg.target == 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();
return false;
}
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;
for (;;) {
prev = p;
p = p.next;
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
msg.next = p; // invariant: p == prev.next
prev.next = msg;
}
// We can assume mPtr != 0 because mQuitting is false.
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
在Handler所有發送消息的方法最終都會調用enqueueMessage()方法，而在調用消息隊列的enqueueMessage()之前會先對Message的target賦值為當前發送消息的Handler對象。在插入的消息中沒有攜帶Handler對象的，則不會插入到消息隊列中。如果這個消息正在使用中，那麼也不會重復插入到該消息隊列中。
MessageQueue中有一個比較重要的成員變量mMessages,這個變量表示當前線程需要處理的消息。將mMessages賦值給變量p，條件p == null || when == 0 || when < p.when表達了三種情況，第一種：當前消息隊列沒有需要處理的消息；第二種：插入處理消息的時間為0；第三種：插入的消息處理的時間小於當前需要處理消息的處理時間。這三種情況都是需要優先將該插入的消息插入到單鏈表的首部。該插入的消息的next值為當前需要處理的消息，next值可能為null，不為null的時候則是一個單鏈表，插入的消息會加入到該鏈表中去。第四種情況：插入的消息的處理時間大於等於當前需要處理的消息的處理時間，那麼插入的消息還沒那麼快需要處理，因而需要插入到鏈表中的合適位置，這個鏈表是按照處理時間從小到大的順序來排列的。後續else中代碼主要是將插入的消息插入到指定位置的算法處理，關於消息的插入實現原理基本就是這樣。
2、取出消息
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;
if (msg != null && msg.target == null) {
// Stalled by a barrier. Find the next asynchronous message in the queue.
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
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;
}
// Process the quit message now that all pending messages have been handled.
if (mQuitting) {
dispose();
return null;
}
// 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.
if (pendingIdleHandlerCount < 0 && (mMessages == null || now < mMessages.when)) {
pendingIdleHandlerCount = mIdleHandlers.size();
}
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.
for (int i = 0; i < pendingIdleHandlerCount; i++) {
final IdleHandler idler = mPendingIdleHandlers[i];
mPendingIdleHandlers[i] = null; // release the reference to the handler
boolean keep = false;
try {
keep = idler.queueIdle();
} catch (Throwable t) {
Log.wtf(TAG, "IdleHandler threw exception", t);
}
if (!keep) {
synchronized (this) {
mIdleHandlers.remove(idler);
}
}
}
// Reset the idle handler count to 0 so we do not run them again.
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;
}?}
在Looper中的loop()方法中會循環消息隊列中的消息，那麼就會調用next()方法從消息隊列中取出消息來處理。在next()中的同步代碼塊中主要是對消息隊列的處理，將符合條件的消息取出，這裡考慮到了消息可能未攜帶Handler的情況，也有消息處理的時間還沒到的情況就會計算取出消息的時間，前置消息為null和不為null的情況，這些情況都會將消息取出。
之前在loop()方法中說到會阻住，那是什麼時候開始阻住的，這裡在同步代碼塊中又一個參數pendingIdleHandlerCount，當它的值小於等於0時就會標志mBlocked為true，這裡會執行continue操作，會繼續下一次循環操作，如果依然沒有消息需要處理則重復這樣的操作，從而達到阻住的效果。
Handler的工作主要是發送消息和處理消息，前面已經簡要說明了消息是如何發送的。這裡再詳細分析一下，Handler發送消息的方式有很多種，但是最終都是通過調用sendMessageAtTime()方法來實現的。
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);
}
queue的值為在創建Handler對象時創建的消息隊列mQueue,如果queue為null，則發送消息失敗，當不為null時，則會調用enqueueMessage()方法。
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
msg.target = this是將Handler對象與message關聯起來，再調用Looper創建的消息隊列中的queue.enqueueMessage()方法，則會將消息插入到消息隊列。
當消息發送到消息隊列，消息隊列中有需要處理的消息，則Looper通過loop()方法從消息隊列中取出需要處理的消息。之前分析了處理消息時，與消息關聯的Handler對象調用dispatchMessage()方法，將消息分發給Handler來處理。
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
此處的分發處理方式受創建Handler對象和插入消息方式的影響。
如果使用的是post系列方法發送消息，那麼會傳入一個Runable對象，該對象會通過getPostMessage()方法與Message關聯，那麼在分發消息時就會執行handleCallback()方法，
private static void handleCallback(Message message) {
message.callback.run();
}
從而執行Runable對象中的run()方法。
如果使用的是在創建Handler對象時傳入了CallBack回調，那麼會執行mCallback.handleMessage()方法。
如果不是以上兩種情況，則直接使用Handler中的handleMessage()方法來處理消息。而以上處理消息的業務邏輯就是程序員自己需要實現的。
上節獨立分析了涉及到的每一個類的工作原理，這節將整體分析一下消息機制的工作原理。
Android的消息處理機制主要是圍繞消息隊列來實現的，在一個線程中通過調用Looper.prepare()方法來創建消息隊列和Looper對象，在該線程中創建能發送和處理消息的Handler對象，而Handler通過Looper對象來關聯消息隊列。Handler發送消息到與之關聯的消息隊列(MessageQueue對象)，通過MessageQueue對象的enqueueMessage的方法將消息插入到消息隊列當中。而在發送的消息中，又將Handler與消息建立對應關系，每一個消息中的target就是發送消息的Handler對象。而Looper對象又通過loop方法不斷的循環消息，取出需要處理的消息，通過消息中關聯的Handler對象分發消息(dispatchMessage)給對應的Handler來處理消息。
消息處理機制在Android應用程序中是比較重要的一個知識點，也是運用比較廣泛的一個知識點，在Android源碼中主要由分個場景來使用，第一個是應用程序主線程的應用；第二個是與UI有關的子線程的應用；第三個是與UI無關的子線程的應用。
Android應用程序的主線程是以ActivityThread靜態函數main()為入口。
public static void main(String[] args) {? ...
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new LogPrinter(Log.DEBUG, "ActivityThread"));
}
// End of event ActivityThreadMain.?Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");? }
這裡調用Looper中的prepareMainLooper()方法來創建Looper和MessageQueue，而主線程中的Handler對象是ActivityThread中的H，這裡主要是處理四大組件相關的處理消息。
在Android應用程序開發中使用過AsyncTask，其中就使用了消息機制，在內部創建了一個InternalHandler（Handler）對象，而調用的Looper是UI主線的Looper，代碼如下：
private static class InternalHandler extends Handler {
public InternalHandler() {
super(Looper.getMainLooper());
}
@SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
@Override
public void handleMessage(Message msg) {
AsyncTaskResult result = (AsyncTaskResult) msg.obj;
switch (msg.what) {
case MESSAGE_POST_RESULT:
// There is only one result
result.mTask.finish(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}
當在子線程處理完耗時任務之後，通過InternalHandler發送消息到主線程中的消息隊列當中，當主線程中的Looper進入循環取出該消息則把消息分發給InternalHandler來處理，從而達到刷新UI的作用。
在Android應用程序框架層設計了一個HandlerThread類，在run方法中執行了Looper的prepare()和loop()方法。
下面介紹一下如何在這種場景下使用。
首先創建HandlerThread對象，
HandlerThread handlerThread = new HandlerThread(“yishon test”);
為了在handlerThread中創建Looper和MessageQueue對象，則需啟動該線程。
handlerThread.start();
我們可以利用Handler的post方法來發送一個消息，那麼
Handler handler = new Handler(handlerThread.getLooper());
handler.post(new Runable {
public void run() {
//需要實現的業務操作
}
});
（1）不能在同一個線程中多次調用prepare()方法，否則會出現運行時異常。
（2）在同一個線程中可以初始化多個Handler對象，這些對象都可以發送消息將消息插入到同一個消息隊列中。
（3）如果Handler發送兩個消息需要處理的時間是相同的，則先發送者先處理。
如何讓你的的小米手機運行更流暢
小米是目前國內用的較多的手機,米粉們用手機用多了發現小米手機變慢了,怎麼提高小米手機的速度呢!要注意以下幾點。 1:開機時間 需要打開權
Android Animation實戰之一個APP的ListView的動畫效果
熟悉了基礎動畫的實現後，便可以試著去實現常見APP中出現過的那些精美的動畫。今天我主要給大家引入一個APP的ListView的動畫效果： 當展示ListView時，Lis
Android 動畫詳解之View動畫
為了讓用戶的使用更舒適所以有些情況使用動畫是很有必要的，Android在3.0以前支持倆種動畫Tween動畫以及Frame動畫。Tween動畫支持簡單的平移，縮放，旋轉，
android實現類似於支付寶余額快速閃動的效果
效果如下： 此圖片不會動，但實際上是會快速跳動的。 之前看到有支付寶的效果非常牛逼。就是進去看到余額呼噜噜的直接上躥下跳到具體數字，效果帥，
