Handler那些事

語言: CN / TW / HK

作者:小呆呆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;
    }
}

總結下原始碼裡面表達的意思

  1. next()內部是個死迴圈,你可能會疑惑,只是拿下一節點的訊息,為啥要死迴圈?

為了執行延時訊息以及同步屏障等等,這個死迴圈是必要的

  1. nativePollOnce阻塞方法:到了超時時間(nextPollTimeoutMillis)或者通過喚醒方式(nativeWake),會解除阻塞狀態

nextPollTimeoutMillis大於等於零,會規定在此段時間內休眠,然後喚醒 訊息佇列為空時,nextPollTimeoutMillis為-1,進入阻塞;重新有訊息進入佇列,插入頭結點的時候會觸發nativeWake喚醒方法

  1. 如果 msg.target == null為零,會進入同步屏障狀態

會將msg訊息死迴圈到末尾節點,除非碰到非同步方法 如果碰到同步屏障訊息,理論上會一直死迴圈上面操作,並不會返回訊息,除非,同步屏障訊息被移除訊息佇列

  1. 當前時刻和返回訊息的when判定

訊息when代表的時刻:一般都是傳送訊息的時刻,如果是延時訊息,就是  傳送時刻+延時時間

當前時刻小於返回訊息的when:進入阻塞,計算時間差,給nativePollOnce設定超時時間,超時時間一到,解除阻塞,重新迴圈取訊息

當前時刻大於返回訊息的when:獲取可用訊息返回

  1. 訊息返回後,會將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補給站

點個 在看 你最好看