Handler那些事
作者：小呆呆666
連結：https://juejin.cn/post/6950146347731255327
前言
Handler屬於八股文中非常經典的一個考題了，導致這個知識點很多時候，考官都懶得問了；這玩意很久之前就看過，但是過了一段時間，就很容易忘記，但是處理記憶體洩漏，IdleHandler之類的考點答案肯定很難忘。。。雖然考官很多時候不屑問，但是要是問到了，你忘了且不知道怎麼回答，那就很尷尬了
鄙人也來炒個剩飯，力求通俗易懂的來描述下Handler機制的整個流程；相關知識點，畫了一些流程圖，時序圖來展示其執行機制，力爭讓本文圖文並茂！
文章中關鍵方法原始碼，可以直接點選方法名，跳轉檢視對應方法的原始碼
如果看了沒收穫，噴我！
總流程
開頭需要建立個handler作用的總體印象，下面畫了一個總體的流程圖
從上面的流程圖可以看出，總體上是分幾個大塊的
-
Looper.prepare()、Handler()、Looper.loop() 總流程
-
收發訊息
-
分發訊息
需要詳細的檢視該思維導圖，請右鍵下載後檢視
使用
先來看下使用，不然原始碼，原理圖搞了一大堆，一時想不起怎麼用的，就尷尬了 使用很簡單，此處僅做個展示，大家可以熟悉下 演示程式碼儘量簡單是為了演示，關於靜態內部類持有弱引用或者銷燬回撥中清空訊息佇列之類，就不在此處展示了
來看下訊息處理的分發方法：dispatchMessage(msg)
Handler.java
...
public void dispatchMessage(@NonNull Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
...
從上面原始碼可知，handler的使用總的來說，分倆大類，細分三小類
-
收發訊息一體
-
handleCallback(msg)
-
收發訊息分開
-
mCallback.handleMessage(msg)
-
handleMessage(msg)
收發一體
-
handleCallback(msg)
-
使用post形式，收發都是一體，都在post()方法中完成，此處不需要建立Message例項等，post方法已經完成這些操作
public class MainActivity extends AppCompatActivity {
private TextView msgTv;
private Handler mHandler = new Handler();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
msgTv = findViewById(R.id.tv_msg);
//訊息收發一體
new Thread(new Runnable() {
@Override public void run() {
String info = "第一種方式";
mHandler.post(new Runnable() {
@Override public void run() {
msgTv.setText(info);
}
});
}
}).start();
}
}
收發分開
mCallback.handleMessage(msg)
實現Callback介面
public class MainActivity extends AppCompatActivity {
private TextView msgTv;
private Handler mHandler = new Handler(new Handler.Callback() {
//接收訊息,重新整理UI
@Override public boolean handleMessage(@NonNull Message msg) {
if (msg.what == 1) {
msgTv.setText(msg.obj.toString());
}
//false 重寫Handler類的handleMessage會被呼叫, true 不會被呼叫
return false;
}
});
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
msgTv = findViewById(R.id.tv_msg);
//傳送訊息
new Thread(new Runnable() {
@Override public void run() {
Message message = Message.obtain();
message.what = 1;
message.obj = "第二種方式 --- 1";
mHandler.sendMessage(message);
}
}).start();
}
}
handleMessage(msg)
重寫Handler類的handlerMessage(msg)方法
public class MainActivity extends AppCompatActivity {
private TextView msgTv;
private Handler mHandler = new Handler() {
//接收訊息,重新整理UI
@Override public void handleMessage(@NonNull Message msg) {
super.handleMessage(msg);
if (msg.what == 1) {
msgTv.setText(msg.obj.toString());
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
msgTv = findViewById(R.id.tv_msg);
//傳送訊息
new Thread(new Runnable() {
@Override public void run() {
Message message = Message.obtain();
message.what = 1;
message.obj = "第二種方式 --- 2";
mHandler.sendMessage(message);
}
}).start();
}
}
prepare和loop
大家肯定有印象，在子執行緒和子執行緒的通訊中，就必須在子執行緒中初始化Handler，必須這樣寫
prepare在前，loop在後，固化印象了
new Thread(new Runnable() {
@Override public void run() {
Looper.prepare();
Handler handler = new Handler();
Looper.loop();
}
});
為啥主執行緒不需要這樣寫，聰明你肯定想到了，在入口出肯定做了這樣的事
ActivityThread.java
...
public static void main(String[] args) {
...
//主執行緒Looper
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
//主執行緒的loop開始迴圈
Looper.loop();
...
}
...
為什麼要使用prepare和loop？我畫了個圖，先讓大家有個整體印象
總結下就是
-
Looper.prepare()：生成Looper物件，set在ThreadLocal裡
-
handler建構函式：通過Looper.myLooper()獲取到ThreadLocal的Looper物件
-
Looper.loop()：內部有個死迴圈，開始事件分發了；這也是最複雜，幹活最多的方法
具體看下每個步驟的原始碼，這裡也會標定好連結，方便大家隨時過去檢視
Looper.loop()
可以看見，一個執行緒內，只能使用一次prepare()，不然會報異常的
Looper.java
...
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));
}
...
Handler()
這裡通過Looper.myLooper() ---> sThreadLocal.get()拿到了Looper例項
Handler.java
...
@Deprecated
public Handler() {
this(null, false);
}
public Handler(@Nullable 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 " + Thread.currentThread()
+ " that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
...
Looper.java
...
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
...
Looper.loop()
該方法分析，在分發訊息裡講
-
精簡了大量原始碼，詳細的可以點選上面方法名
-
Message msg = queue.next()：遍歷訊息
-
msg.target.dispatchMessage(msg)：分發訊息
-
msg.recycleUnchecked()：訊息回收，進入訊息池
Looper.java
...
public static void loop() {
final Looper me = myLooper();
...
final MessageQueue queue = me.mQueue;
...
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
...
try {
msg.target.dispatchMessage(msg);
if (observer != null) {
observer.messageDispatched(token, msg);
}
dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
} catch (Exception exception) {
if (observer != null) {
observer.dispatchingThrewException(token, msg, exception);
}
throw exception;
} finally {
ThreadLocalWorkSource.restore(origWorkSource);
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
....
msg.recycleUnchecked();
}
}
...
收發訊息
收發訊息的操作口都在Handler裡，這是我們最直觀的接觸的點
下方的思維導圖整體做了個概括
前置知識
在說傳送和接受訊息之前，必須要先解釋下，Message中一個很重要的屬性：when
when這個變數是Message中的，傳送訊息的時候，我們一般是不會設定這個屬性的，實際上也無法設定，只有內部包才能訪問寫的操作；將訊息加入到訊息佇列的時候會給傳送的訊息設定該屬性。訊息加入訊息佇列方法：enqueueMessage(...)
在我們使用sendMessage傳送訊息的時候，實際上也會呼叫sendMessageDelayed延時傳送訊息發放，不過此時傳入的延時時間會預設為0，來看下延時方法：sendMessageDelayed
public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
這地方呼叫了sendMessageAtTime方法，此處！做了一個時間相加的操作：SystemClock.uptimeMillis() + delayMillis
-
SystemClock.uptimeMillis()：這個方法會返回一個毫秒數值，返回的是，開啟裝置到此刻所消耗的毫秒時間，這很明顯是個相對時間刻！
-
delayMillis：就是我們傳送的延時毫秒數值
後面會將這個時間刻賦值給when：when = SystemClock.uptimeMillis() + delayMillis 說明when代表的是開機到現在的一個時間刻，通俗的理解，when可以理解為：現實時間的某個現在或未來的時刻（實際上when是個相對時刻，相對點就是開機的時間點）
傳送訊息
傳送訊息涉及到倆個方法：post(...)和sendMessage(...)
post(Runnable)：傳送和接受訊息都在post中完成 sendMessage(msg)：需要自己傳入Message訊息物件 看下原始碼
使用post會自動會通過getPostMessage方法建立Message物件 在enqueueMessage中將生成的Message加入訊息佇列，注意
此方法給msg的target賦值當前handler之後，才進行將訊息新增的訊息佇列的操作 msg.setAsynchronous(true)：設定Message屬性為非同步，預設都為同步；設定為非同步的條件，需要手動在Handler構造方法裡面設定
Handler.java
...
//post
public final boolean post(@NonNull Runnable r) {
return sendMessageDelayed(getPostMessage(r), 0);
}
//生成Message物件
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
//sendMessage方法
public final boolean sendMessage(@NonNull Message msg) {
return sendMessageDelayed(msg, 0);
}
public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
public boolean sendMessageAtTime(@NonNull 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);
}
///將Message加入詳細佇列
private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
long uptimeMillis) {
//設定target
msg.target = this;
msg.workSourceUid = ThreadLocalWorkSource.getUid();
if (mAsynchronous) {
//設定為非同步方法
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
...
enqueueMessage(...)：精簡了一些程式碼，完整程式碼，可點選左側方法名
Message通過enqueueMessage加入訊息佇列 請明確：when = SystemClock.uptimeMillis() + delayMillis，when代表的是一個時間刻度，訊息進入到訊息佇列，是按照時間刻度排列的，時間刻度按照從小到大排列，也就是說訊息在訊息佇列中：按照從現在到未來的循序排隊 這地方有幾種情況，記錄下：mMessage為當前訊息分發到的訊息位置
mMessage為空，傳入的msg則為訊息連結串列頭，next置空 mMessage不為空、訊息佇列中沒有延時訊息的情況：從當前分發位置移到連結串列尾，將傳入的msg插到連結串列尾部，next置空
mMessage不為空、含有延時訊息的情況：舉個例子
A，B，C訊息依次傳送，三者分邊延時：3秒，1秒，2秒 { A(3000)、B(1000)、C(2000) } 這是一種理想情況：三者依次進入，進入之間的時間差小到忽略，這是為了方便演示和說明 這種按照時間遠近的循序排列，可以保證未延時或者延時時間較小的訊息，能夠被及時執行 在訊息佇列中的排列為：B ---> C ---> A
MessageQueue.java
...
boolean enqueueMessage(Message msg, long when) {
...
synchronized (this) {
...
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;
}
...
來看下發送的訊息插入訊息佇列的圖示
接收訊息
接受訊息相對而言就簡單多
dispatchMessage(msg)：關鍵方法呀
Handler.java
...
public void dispatchMessage(@NonNull Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
...
handleCallback(msg)
觸發條件：Message訊息中實現了handleCallback回撥 現在基本上只能使用post()方法了，setCallback(Runnable r) 被表明為@UnsupportedAppUsage，被hide了，沒法呼叫，如果使用反射倒是可以呼叫，但是沒必要。。。
mCallback.handleMessage(msg)
觸發條件
使用sendMessage方法傳送訊息（必須） 實現Handler的Callback回撥
分發的訊息，會在Handler中實現的回撥中分發
handleMessage(msg)
觸發條件
使用sendMessage方法傳送訊息（必須） 未實現Handler的Callback回撥 實現了Handler的Callback回撥，返回值為false（mCallback.handleMessage(msg)）
需要重寫Handler類的handlerMessage方法
分發訊息
訊息分發是在loop()中完成的，來看看loop()這個重要的方法
Looper.loop()：精簡了巨量原始碼，詳細的可以點選左側方法名
Message msg = queue.next()：遍歷訊息 msg.target.dispatchMessage(msg)：分發訊息 msg.recycleUnchecked()：訊息回收，進入訊息池
Looper.java
...
public static void loop() {
final Looper me = myLooper();
...
final MessageQueue queue = me.mQueue;
...
for (;;) {
//遍歷訊息池,獲取下一可用訊息
Message msg = queue.next(); // might block
...
try {
//分發訊息
msg.target.dispatchMessage(msg);
...
} catch (Exception exception) {
...
} finally {
...
}
....
//回收訊息,進圖訊息池
msg.recycleUnchecked();
}
}
...
遍歷訊息
遍歷訊息的關鍵方法肯定是下面這個
Message msg = queue.next()：Message類中的next()方法；當然這必須要配合外層for（無限迴圈）來使用，才能遍歷訊息佇列
來看看這個Message中的next()方法吧
next()：精簡了一些原始碼，完整的點選左側方法名
MessageQueue.java
...
Message next() {
final long ptr = mPtr;
...
int pendingIdleHandlerCount = -1; // -1 only during first iteration
int nextPollTimeoutMillis = 0;
for (;;) {
...
//阻塞，除非到了超時時間或者喚醒
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;
// 這是關於同步屏障（SyncBarrier）的知識，放在同步屏障欄目講
if (msg != null && msg.target == null) {
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {
if (now < msg.when) {
//每個訊息處理有耗時時間，之間存在一個時間間隔（when是將要執行的時間點）。
//如果當前時刻還沒到執行時刻（when），計算時間差值，傳入nativePollOnce定義喚醒阻塞的時間
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
mBlocked = false;
//該操作是把非同步訊息單獨從訊息佇列裡面提出來,然後返回,返回之後,該非同步訊息就從訊息佇列裡面剔除了
//mMessage仍處於未分發的同步訊息位置
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
if (DEBUG) Log.v(TAG, "Returning message: " + msg);
msg.markInUse();
//返回符合條件的Message
return msg;
}
} else {
// No more messages.
nextPollTimeoutMillis = -1;
}
//這是處理呼叫IdleHandler的操作,有幾個條件
//1、當前訊息佇列為空(mMessages == null)
//2、已經到了可以分發下一訊息的時刻（now < mMessages.when）
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);
}
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;
}
}
總結下原始碼裡面表達的意思
-
next()內部是個死迴圈，你可能會疑惑，只是拿下一節點的訊息，為啥要死迴圈？
為了執行延時訊息以及同步屏障等等，這個死迴圈是必要的
-
nativePollOnce阻塞方法：到了超時時間(nextPollTimeoutMillis)或者通過喚醒方式(nativeWake)，會解除阻塞狀態
nextPollTimeoutMillis大於等於零，會規定在此段時間內休眠，然後喚醒 訊息佇列為空時，nextPollTimeoutMillis為-1，進入阻塞；重新有訊息進入佇列，插入頭結點的時候會觸發nativeWake喚醒方法
-
如果 msg.target == null為零，會進入同步屏障狀態
會將msg訊息死迴圈到末尾節點，除非碰到非同步方法 如果碰到同步屏障訊息，理論上會一直死迴圈上面操作，並不會返回訊息，除非，同步屏障訊息被移除訊息佇列
-
當前時刻和返回訊息的when判定
訊息when代表的時刻：一般都是傳送訊息的時刻，如果是延時訊息，就是 傳送時刻+延時時間
當前時刻小於返回訊息的when：進入阻塞，計算時間差，給nativePollOnce設定超時時間，超時時間一到，解除阻塞，重新迴圈取訊息
當前時刻大於返回訊息的when：獲取可用訊息返回
-
訊息返回後，會將mMessage賦值為返回訊息的下一節點（只針對不涉及同步屏障的同步訊息）
這裡簡單的畫了個流程圖
分發訊息
分發訊息主要的程式碼是：msg.target.dispatchMessage(msg);
也就是說這是Handler類中的dispatchMessage(msg)方法
dispatchMessage(msg)
public void dispatchMessage(@NonNull Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
可以看到，這裡的程式碼，在收發訊息欄目的接受訊息那塊已經說明過了，這裡就無須重複了
訊息池
msg.recycleUnchecked()是處理完成分發的訊息，完成分發的訊息並不會被回收掉，而是會進入訊息池，等待被複用
recycleUnchecked()：回收訊息的程式碼還是蠻簡單的，來分析下
首先會將當前已經分發處理的訊息，相關屬性全部重置，flags也標誌可用 訊息池的頭結點會賦值為當前回收訊息的下一節點，當前訊息成為訊息池頭結點 簡言之：回收訊息插入訊息池，當做頭結點 需要注意的是：訊息池有最大的容量，如果訊息池大於等於預設設定的最大容量，將不再接受回收訊息入池
預設最大容量為50：MAX_POOL_SIZE = 50
Message.java
...
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 = UID_NONE;
workSourceUid = UID_NONE;
when = 0;
target = null;
callback = null;
data = null;
synchronized (sPoolSync) {
if (sPoolSize < MAX_POOL_SIZE) {
next = sPool;
sPool = this;
sPoolSize++;
}
}
}
來看下訊息池回收訊息圖示
既然有將已使用的訊息回收到訊息池的操作，那肯定有獲取訊息池裡面訊息的方法了
obtain()：程式碼很少，來看看 如果訊息池不為空：直接取訊息池的頭結點，被取走頭結點的下一節點成為訊息池的頭結點 如果訊息池為空：直接返回新的Message例項
Message.java
...
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();
}
來看下從訊息池取一個訊息的圖示
IdleHandler
在MessageQueue類中的next方法裡，可以發現有關於對IdleHandler的處理，大家可千萬別以為它是什麼Handler特殊形式之類，這玩意就是一個interface，裡面抽象了一個方法，結構非常的簡單
next()：精簡了大量原始碼，只保留IdleHandler處理的相關邏輯；完整的點選左側方法名
MessageQueue.java
...
Message next() {
final long ptr = mPtr;
...
int pendingIdleHandlerCount = -1; // -1 only during first iteration
int nextPollTimeoutMillis = 0;
for (;;) {
...
//阻塞，除非到了超時時間或者喚醒
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;
...
//這是處理呼叫IdleHandler的操作,有幾個條件
//1、當前訊息佇列為空(mMessages == null)
//2、未到到了可以分發下一訊息的時刻（now < mMessages.when）
//3、pendingIdleHandlerCount < 0表明：只會在此for迴圈裡執行一次處理IdleHandler操作
if (pendingIdleHandlerCount < 0
&& (mMessages == null || now < mMessages.when)) {
pendingIdleHandlerCount = mIdleHandlers.size();
}
if (pendingIdleHandlerCount <= 0) {
mBlocked = true;
continue;
}
if (mPendingIdleHandlers == null) {
mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
}
mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
}
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);
}
}
}
pendingIdleHandlerCount = 0;
nextPollTimeoutMillis = 0;
}
}
實際上從上面的程式碼裡面，可以分析出很多資訊
IdleHandler相關資訊
-
呼叫條件
當前訊息佇列為空(mMessages == null) 或 未到分發返回訊息的時刻 在每次獲取可用訊息的死迴圈中，IdleHandler只會被處理一次：處理一次後pendingIdleHandlerCount為0，其迴圈不可再被執行
-
實現了IdleHandler中的queueIdle方法
返回false，執行後，IdleHandler將會從IdleHandler列表中移除，只能執行一次：預設false 返回true，每次分發返回訊息的時候，都有機會被執行：處於保活狀態
-
IdleHandler程式碼
MessageQueue.java
...
/**
* Callback interface for discovering when a thread is going to block
* waiting for more messages.
*/
public static interface IdleHandler {
/**
* Called when the message queue has run out of messages and will now
* wait for more. Return true to keep your idle handler active, false
* to have it removed. This may be called if there are still messages
* pending in the queue, but they are all scheduled to be dispatched
* after the current time.
*/
boolean queueIdle();
}
public void addIdleHandler(@NonNull IdleHandler handler) {
if (handler == null) {
throw new NullPointerException("Can't add a null IdleHandler");
}
synchronized (this) {
mIdleHandlers.add(handler);
}
}
public void removeIdleHandler(@NonNull IdleHandler handler) {
synchronized (this) {
mIdleHandlers.remove(handler);
}
}
-
怎麼使用IdleHandler呢？
這裡簡單寫下用法，可以看看，留個印象
public class MainActivity extends AppCompatActivity {
private TextView msgTv;
private Handler mHandler = new Handler();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
msgTv = findViewById(R.id.tv_msg);
//新增IdleHandler實現類
mHandler.getLooper().getQueue().addIdleHandler(new InfoIdleHandler("我是IdleHandler"));
mHandler.getLooper().getQueue().addIdleHandler(new InfoIdleHandler("我是大帥比"));
//訊息收發一體
new Thread(new Runnable() {
@Override public void run() {
String info = "第一種方式";
mHandler.post(new Runnable() {
@Override public void run() {
msgTv.setText(info);
}
});
}
}).start();
}
//實現IdleHandler類
class InfoIdleHandler implements MessageQueue.IdleHandler {
private String msg;
InfoIdleHandler(String msg) {
this.msg = msg;
}
@Override
public boolean queueIdle() {
msgTv.setText(msg);
return false;
}
}
}
總結
-
通俗的講：當所有訊息處理完了 或者 你傳送了延遲訊息，在這倆種空閒時間裡，都滿足執行IdleHandler的條件
-
這地方需要說明下，如果延遲訊息時間設定過短的；IdleHandler可能會在傳送訊息後執行，畢竟執行到next這步也需要一點時間，延遲時間設定長點，你就可以很明顯得發現，IdleHandler在延遲的空隙間執行了！
-
從其原始碼上，可以看出來，IdlerHandler是在訊息分發的空閒時刻，專門用來處理相關事物的
最後，由於篇幅過長，避免產生閱讀困難，將有關同步屏障部分拆分到下期。感興趣的可以期待一下~
掃描二維碼
獲取更多精彩
Android補給站
點個 在看 你最好看
- 協程到底是怎麼切換執行緒的？
- 元件化開花，就問你香不香
- Kotlin 基礎 | 拒絕語法噪音
- 玩轉LayoutInflater
- 淺談Android熱更新的前因後果
- 如何學好設計，做好架構？ 核心思想才是關鍵
- Kotlin 內聯類 inline class請了解一下
- Android MaterialButton使用詳解，告別shape、selector
- 入木三分：從設計者角度看Retrofit原理
- 使用Jetpack Compose完成你的自定義Layout
- 為了能夠摸魚，我走上了歧路
- 自信，這是最好的ThreadLocal分析
- Android&Kotlin編譯速度原理剖析
- Android 面試之必問Java基礎
- Kotlin 基礎 | 委託及其應用
- 引入Jetpack架構後，你的App會發生哪些變化？
- Handler那些事
- android佈局優化的幾個建議
- 面試：ViewModel為何橫豎屏切換時不銷燬？
- Android Java Zygote啟動