Android Handler源碼深入探究
1.android 消息循環有4個重要的類Handler、Message、Looper、MessageQueue
handler 用來發送、處理消息。
Message 是消息的載體。
MessageQueue 是一個消息隊列，既然是隊列，就有入隊、出隊的處理。
Looper 創建一個消息循環。不斷的從MessageQueue中讀取消息、並分發給相應的Handler進行處理。
2.我們都知道main函數是Java程序的入口，android程序也不例外。
android App的唯一入口就是ActivityThread中的 main函數。 這個函數是由Zygote創建app進程後 通過反射的方式調用的。
當一個App啟動時，會先執行這個main方法，在ActivityThread，main方法中，
public static void main(String[] args) {
//創建一個消息循環
Looper.prepareMainLooper();
//創建ActivityThread對象
ActivityThread thread = new ActivityThread();
//創建Application、啟動MainActivity
thread.attach(false, startSeq);
//使消息循環奔跑起來
Looper.loop();
//拋瞭一個異常 主線程的Looper 意外退出瞭，
//所以loop中的for循環要阻塞在這裡，一旦main函數執行完畢，進程也就退出瞭。
//並且一直要提取消息，處理消息。
throw new RuntimeException("Main thread loop unexpectedly exited");
}
3. 首先看Looper是如何創建的。
Looper.prepareMainLooper();
public static void prepareMainLooper() {
prepare(false);
//同步方法保證一個sMainLooper 隻被賦值一次。
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
//創建一個Looper對象，並保存在瞭 sThreadLocal中。關於ThreadLocal，也是很重要的一個知識點。
private static void prepare(boolean quitAllowed) {
//一個線程隻能有一個Looper，
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
}
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
//在Looper中創建瞭MessageQueue
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
至此，創建的代碼執行完畢。
總結一句話就是，app啟動時，會創建Looper，並且保證一個線程隻能創建一個Looper。
創建Looper的同時，也創建的消息隊列 MessageQueue。這些都是消息循環的準備工作。
通過Looper.loop，這個消息循環就跑起來瞭。
Looper.loop();
/**
* Run the message queue in this thread.
*/
public static void loop() {
for (; ; ) {
//從消息循環中提取消息。消息時會阻塞在這裡。
Message msg = queue.next(); // might block
//target-->Handler.Msg持有handler的引用。
msg.target.dispatchMessage(msg);
}
}
4.在MessageQueue中enqueueMessage()插入消息、next()提取消息方法。
插入消息
//Message.obtain()從Message消息緩存池內獲得一個消息。
handler.sendMessage(Message.obtain());
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;
return enqueueMessage(queue, msg, uptimeMillis);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
//this==handler,在這裡給message.target賦值瞭handler。
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
//在MessageQueue中用一個單線鏈表來保存消息。
//在這個消息的單鏈表中，是按消息執行的時間先後，從小到大排序的。
//mMessages 是這個單鏈表的第一個消息。
boolean enqueueMessage(Message msg, long when) {
//通過sendMessage並不能發送handler==null的消息。
if (msg.target == null) {
throw new IllegalArgumentException("Message must have a target.");
}
synchronized (this) {
msg.markInUse();
msg.when = when;
//將鏈表中第一個消息賦值給p
Message p = mMessages;
boolean needWake;
//如果p==null說明消息列表中沒有要被執行的消息。
//如果when==0說明新新添加的消息要被馬上執行，所以要排在列表的頭部
//如果when<p.when，說明新添加的消息，比消息隊列第一個消息要先執行，所以也要放在頭部
if (p == null || when == 0 || when < p.when) {
// New head, wake up the event queue if blocked.
//將原來的頭部消息賦值給新消息的next
msg.next = p;
//將新加的消息賦值給mMessage。因為mMessages這個變量用來保存消息列表的第一個消息。
mMessages = msg;
} else {//如果when>=p.when，則需要遍歷消息隊列，將新添加的消息插入到隊列中間，
Message prev;
for (;;) {
prev = p;//把當前的賦值給前一個
p = p.next;//把下一個賦值給當前的
//如果p==null說明已經遍歷到瞭鏈表末尾。
//如果新增的消息時間小於瞭p的when。那麼這個消息應該插入到prev之後，p之前。
if (p == null || when < p.when) {
break;
}
}
//新增消息在p之前，prev之後
msg.next = p; // invariant: p == prev.next
prev.next = msg;
}
}
return true;
}
提取消息：
Message next() {
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
//開始休眠，nextPollTimeoutMillis下次被喚醒的時間
//如果是-1則一直休眠，直到有新的消息再喚醒消息隊列。
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
// Try to retrieve the next message. Return if found.
//開始遍歷消息隊列，返回找到的消息。
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
//消息隊列，頭部消息
//如果msg！=null,但是msg.target==null,sendMessage中，是不允許發送handler為null的消息的。
//target==null的消息是系統發送的，先發送一個同步屏障消息，再發送直到isAsynchronous = true的異步消息。
//這樣做的目的就保證瞭這個異步消息有更高優先級被執行，先從消息隊列中提取。
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());//直到isAsynchronous = true，也就是找到瞭同步屏障的異步消息
}
}
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 {
//如果前一個消息是null，說明當前就是消息頭，
//將消息隊列頭部消息指向當前提取出消息的下一個消息。
mMessages = msg.next;
}
//將找到的消息的下一個賦值null，和原來的消息隊列脫離關系。
msg.next = null;
if (false) Log.v("MessageQueue", "Returning message: " + msg);
return msg;
}
} else {//如果msg==null
// No more messages.
nextPollTimeoutMillis = -1;
}
}
}
}
handler會涉及到native的代碼。在native層使用的epoll機制，這個後面在深入分享。
這裡涉及到瞭一個消息屏障的概念，有機會單獨寫文章來分享。
//同步屏障消息
void scheduleTraversals() {
if (!mTraversalScheduled) {
mTraversalScheduled = true;
//發送一個同步屏障消息
mTraversalBarrier = mHandler.getLooper().postSyncBarrier();
mChoreographer.postCallback(
Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
}
}
5. 至此，整個消息循環大體的流程已經完成。但是關於handler的面試題很多。
比如為啥handler會導致Activity內存泄漏？如何解決？
內存泄漏的本質就是長聲明周期對象持有短聲明周期對象的引用，導致短聲明周期對象，不再使用但內存卻無法被回收。
我們知道handler作為Activity的內部類，持有外部類的引用，所以整個引用鏈是
Activity–>handler–>Message–>MessageQueue.
當activity退出後，如果消息為來的及處理，就有可能會導致Activity無法被GC回收，從而導致內存泄漏。
handler.post(),發送的消息執行在子線程還是主線程？
下面來看消息池。消息池也是一個單項鏈表，長度是50.
靜態對象sPool就是消息隊列的頭部Message。
每次獲取消息時，都會返回消息池中第一個對象。
Message.obtain()
private static Message sPool;
private static final int MAX_POOL_SIZE = 50;
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();
}
到此這篇關於Android Handler源碼深入探究的文章就介紹到這瞭,更多相關Android Handler 內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！
推薦閱讀：
- Android Loop機制中Looper與handler詳細分析
- Android消息機制Handler深入理解
- Android Handler,Message,MessageQueue,Loper源碼解析詳解
- Android消息機制Handler用法總結
- Android Handler機制詳解原理