Handler概述
Handler是Android消息機制的上層接口煞烫，最常見的應(yīng)用就是通過Handler在子線程更新UI。
從創(chuàng)建Handler對象實例入手
- 創(chuàng)建Handler對象
private Handler mHandler = new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
return false;
}
});
在這里覆寫了 handleMessage()方法滞详。
- 點進去看Handler的構(gòu)造函數(shù)凛俱，發(fā)現(xiàn)以上代碼調(diào)用的一個參數(shù)的Handler構(gòu)造方法，在內(nèi)部調(diào)用了兩個參數(shù)的構(gòu)造方法料饥。
-
mLooper = Looper.myLooper(); Handler構(gòu)造函數(shù)的第一行有效代碼蒲犬，調(diào)用了Looper類的靜態(tài)方法獲取Looper實例。點進去的具體代碼如下：
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
> Return the Looper object associated with the current thread. Returns null if the calling thread is not associated with a Looper.
從注釋可以看出岸啡，這個返回的Looper是每一個不同線程的Looper對象原叮，也就是說不同的線程獲得的Looper都是相互沒有干擾的副本。
那么是如何實現(xiàn)同一數(shù)據(jù)類型的不同線程副本巡蘸，具體分析`sThreadLocal.get()`這行代碼
#### ThreadLocal ####
* 首先sThreadLocal是一個ThreadLocal的對象奋隶，先來一小demo:
public static void main(String[] args) {
final ThreadLocal<Integer> test = new ThreadLocal<>();
test.set(1);
System.out.println(Thread.currentThread().getName() + "當(dāng)前值 = " +test.get());
new Thread(){
public void run() {
test.set(2);
System.out.println(Thread.currentThread().getName() + "當(dāng)前值 = " +test.get());
};
}.start();
new Thread(){
public void run() {
test.set(8);
System.out.println(Thread.currentThread().getName() + "當(dāng)前值 = " +test.get());
};
}.start();
new Thread(){
public void run() {
System.out.println(Thread.currentThread().getName() + "當(dāng)前值 = " +test.get());
};
}.start();
}
打印結(jié)果:</br>
main當(dāng)前值 = 1</br>
Thread-0當(dāng)前值 = 2</br>
Thread-1當(dāng)前值 = 8</br>
Thread-2當(dāng)前值 = null</br>
從代碼和結(jié)果中可以看出，ThreadLocal類中有set/get方法悦荒，不同的線程獲取的數(shù)據(jù)都與其自己設(shè)置的相同达布，同時如果沒有調(diào)用set方法設(shè)置，返回的結(jié)果就是null逾冬，也就是說不同的線程擁有互不干擾的對象副本黍聂。
ThreadLocal工作原理
現(xiàn)在來看ThreadLocal的源碼，分析它到底是如何實現(xiàn)的功能身腻。先看set方法：
public void set(T value) {
Thread currentThread = Thread.currentThread();
Values values = values(currentThread);
if (values == null) {
values = initializeValues(currentThread);
}
values.put(this, value);
}
- 在
Values values = values(currentThread)返回了一個localValues,這里涉及到ThreadLocal中的一個靜態(tài)類ThreadLocal.Values产还。 - 接下來進行判斷，如果
localValues為null嘀趟，則調(diào)用initializeValues方法進行初始化脐区，否則會調(diào)用put方法將value存進去。
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的值就保存在LocalValues內(nèi)部名為table的Object數(shù)組中牛隅，Threadlocal的reference字段后面緊跟著value,在這里也就是我們傳進來的Looper。接下來就看看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);
}
get方法先根據(jù)當(dāng)前線程獲取其中的ThreadLocal.Values酌泰，從values中得到Object數(shù)組table媒佣，最后從table中找到存儲的對象。
- 接下來繼續(xù)分析Handler的構(gòu)造方法陵刹，獲取Looper對象之后會判斷默伍，獲取的Looper對象是否為null，如果為null，則拋出異常也糊。
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
從異常的內(nèi)容不難看出炼蹦，在創(chuàng)建handler對象之前，必須要調(diào)用Looper.prepare()方法對Looper對象初始化狸剃。
-
mQueue = mLooper.mQueue;接著又從上一步獲取的當(dāng)前線程的Looper實例中獲取了其保存的MessageQueue（消息隊列）掐隐，這樣就保證了handler的實例與我們Looper實例中MessageQueue關(guān)聯(lián)上了。 -
mCallback = callback;保存了創(chuàng)建Handler實例時覆寫的callback回調(diào)方法钞馁。 -
mAsynchronous = async;保存了創(chuàng)建Handler實例時對異步的設(shè)置瑟枫。 - 以上就創(chuàng)建handler實例的代碼，顯然已經(jīng)成功了指攒。其實具體實現(xiàn)又要看looper內(nèi)部的實現(xiàn)慷妙，以下來分析looper類。
looper
- 在以上創(chuàng)建Handler實例的時候允悦，提到必須要先調(diào)用Looper.prepare()方法進行初始化膝擂，以下代碼：
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));
}
在代碼中，sThreadLocal是一個ThreadLocal對象隙弛，也就是對Looper對象進行了保存架馋，同時進行了一次判斷，判斷sThreadLocal是否為null全闷，否則拋出異常叉寂，這也就說明了Looper.prepare()方法不能被調(diào)用兩次，同時也保證了一個線程只有一個Looper實例总珠。
- 先看
new Looper(quitAllowed)Looper的構(gòu)造方法：
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
1). 創(chuàng)建了一個消息隊列`new MessageQueue(quitAllowed);`</br>
2). 獲取了當(dāng)前線程實例屏鳍。
核心方法loop()
- 現(xiàn)在讓我們才看看Looper中的核心方法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();
}
}
在代碼開頭局服，調(diào)用Looper類的靜態(tài)方法直接返回了sThreadLocal存儲的Looper實例钓瞭，如果me為null則拋出異常，也就是說looper()方法必須在prepare()之后方能運行淫奔。緊接著獲取到了Looper實例中的mQueue（消息隊列）山涡，之后就進入了無限循環(huán)。從消息隊列中取出一條消息唆迁，如果沒有消息就阻塞鸭丛。
關(guān)鍵代碼->msg.target.dispatchMessage(msg);把消息交給了msg的target的dispatchMessage()方法去處理。點開target唐责，可以發(fā)現(xiàn)target其實就是handler對象鳞溉，最后釋放消息占據(jù)的資源msg.recycleUnchecked();。</br>
加入消息隊列
好了說了這么多妒蔚，那么消息是怎么加入到消息隊列MessageQueue中的呢
- 那么現(xiàn)在具體看看平時使用的sendMessage(Message msg)方法具體是如何實現(xiàn)的穿挨。
public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
}
- 其中的
sendMessageDelayed方法
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
- 最后還是調(diào)用了
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);
}
而enqueueMessage方法中
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
在進入方法的第一行，enqueueMessage中首先為meg.target賦值為this肴盏，也就是把當(dāng)前的handler作為msg的target屬性科盛。最終會調(diào)用queue的enqueueMessage的方法，同時可以看出最終調(diào)用了queue.enqueueMessage方法菜皂，那么queue又是什么呢贞绵，其實就是MessageQueue的對象實例，也就是說handler發(fā)出的消息恍飘，最終會保存到消息隊列中去榨崩。
- 接下來再來看
dispatchMessage方法:
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
就會發(fā)現(xiàn)其中的handleMessage(msg);方法中是空的，其實就是需要我們覆寫的最終消息處理方法章母。
在這里還有一個問題母蛛，在Activity中，我們并沒有顯示的調(diào)用Looper.prepare()和Looper.loop()方法乳怎，結(jié)果Handler還是成功的創(chuàng)建了呢彩郊，其實這個因為在Activity的啟動代碼中，已經(jīng)在當(dāng)前的UI線程調(diào)用了Looper.prepare()和Looper.loop()方法蚪缀。
最后對handler機制做一個總結(jié)：</br>
- 首先Looper.prepare()在本線程保存一個Looper實例秫逝，然后在該實例中創(chuàng)建并保存了一個MessageQueue對象，同時因為Looper.prepare()在一個線程中只能調(diào)用一次询枚，所以MessageQueue在一個線程只會存在一個违帆。
- Looper.loop()方法會讓當(dāng)前線程進入一個無限循環(huán)，不斷的從MessageQueue的實例中讀取消息金蜀，然后回調(diào)
msg.target.dispatchMessage(msg)方法刷后。 - 而target就是Handler的實例，那么再看Handler的構(gòu)造函數(shù)渊抄，其首先得到了當(dāng)前線程保存的Looper實例惠险，進而又從Looper實例中獲取了保存的MessageQueue實例，與其相關(guān)聯(lián)抒线。
- 接下來Handler的sendMessage方法班巩，會給msg的target賦值為handler本身，然后加入到MessageQueue中嘶炭。
- 那么回過頭來看Looper.loop()獲取到了消息調(diào)用的dispatchMessage(msg)方法其實最終調(diào)用了我們覆寫的handleMessage方法抱慌。
學(xué)習(xí)的時間不長，有什么不對還請指出眨猎，謝謝指教抑进。
