Handler的原理有哪些
本篇內容主要講解“Handler的原理有哪些”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“Handler的原理有哪些”吧!
成都創新互聯公司主要從事網站建設、網站制作、網頁設計、企業做網站、公司建網站等業務。立足成都服務裕華,十余年網站建設經驗,價格優惠、服務專業,歡迎來電咨詢建站服務:18980820575
總流程
開頭需要建立個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.prepare()
可以看見，一個線程內，只能使用一次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消息對象
看下源碼
此方法給msg的target賦值當前handler之后，才進行將消息添加的消息隊列的操作
msg.setAsynchronous(true)：設置Message屬性為異步，默認都為同步；設置為異步的條件，需要手動在Handler構造方法里面設置
使用post會自動會通過getPostMessage方法創建Message對象
在enqueueMessage中將生成的Message加入消息隊列，注意
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(...)：精簡了一些代碼，完整代碼，可點擊左側方法名
A，B，C消息依次發送，三者分邊延時：3秒，1秒，2秒 { A(3000)、B(1000)、C(2000) }
這是一種理想情況：三者依次進入，進入之間的時間差小到忽略，這是為了方便演示和說明
這種按照時間遠近的循序排列，可以保證未延時或者延時時間較小的消息，能夠被及時執行
在消息隊列中的排列為：B ---> C ---> A
mMessage為空，傳入的msg則為消息鏈表頭，next置空
mMessage不為空、消息隊列中沒有延時消息的情況：從當前分發位置移到鏈表尾，將傳入的msg插到鏈表尾部，next置空
Message通過enqueueMessage加入消息隊列
請明確：when = SystemClock.uptimeMillis() + delayMillis，when代表的是一個時間刻度，消息進入到消息隊列，是按照時間刻度排列的，時間刻度按照從小到大排列，也就是說消息在消息隊列中：按照從現在到未來的循序排隊
這地方有幾種情況，記錄下：mMessage為當前消息分發到的消息位置
mMessage不為空、含有延時消息的情況：舉個例子
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()：回收消息的代碼還是蠻簡單的，來分析下
默認最大容量為50： MAX_POOL_SIZE = 50
首先會將當前已經分發處理的消息，相關屬性全部重置，flags也標志可用
消息池的頭結點會賦值為當前回收消息的下一節點，當前消息成為消息池頭結點
簡言之：回收消息插入消息池，當做頭結點
需要注意的是：消息池有最大的容量，如果消息池大于等于默認設置的最大容量，將不再接受回收消息入池
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的條件
- 響應式網站將成為5G時代有效的助推力 2022-08-01
- 什么是響應式網站建設?跟普通站點有何區別? 2023-04-13
- 響應式網站布局和自適應網站布局區別在哪？ 2022-11-26
- 響應式網站在建設的時候需要遵守哪些原則 2023-03-21
- 成都響應式網站建設有哪些流程要注意？ 2022-07-30
- 做一個響應式網站，想要適應手機和平板三網合 2023-01-03
- 抓住響應式網站核心提升企業網站交互性能 2022-11-20
- 企業網站建設首選響應式網站設計制作類型更符合現代用戶使用習慣 2022-05-20
- 衢州響應式網站設計怎樣表現出用戶體驗？ 2023-03-05
- 響應式網站的優勢 2022-10-20
- 響應式網站發展趨勢是時候了解下 2022-05-02
- 響應式網站建設的特點你了解多少 2016-06-12