不忘初心 砥礪前行, Tomorrow Is Another Day !
本文概要:
- 對於Handler兩個常見的問題
- messageQueue、Looper、Handler之間的關係
前言:
Android的訊息機制主要是指Handler執行機制,handler它的作用就是切換到指定執行緒執行任務,記住是切換到指定執行緒執行任務,可以子執行緒也可以是主執行緒,只是在實際開發中經常應用於更新UI.在handler底層需要MessageQueue與Looper支援.接著我們來具體介紹.
一. 兩個常見問題:
- android為什麼不允許在子執行緒更新UI?
為了避免多執行緒,更新UI執行緒是不安全的.
複製程式碼- 執行緒不安全,對UI訪問為什麼不採用鎖的機制？
鎖機制會造成邏輯複雜並且降低訪問UI的效率,阻塞某些執行緒的執行.
複製程式碼二. messageQueue、Looper、Handler之間的關係
- messageQueue：儲存訊息
- looper: 處理訊息,儲存在ThreadLocal中.
- Handler: 是基於looper構建內部訊息迴圈系統.
對於ThreadLocal如果暫不瞭解,可以先閱讀三. 執行緒管理之ThreadLocal,這樣更容易理解Handler訊息機制.
接下來我們看三劍客的各自工作原理,首先看messageQueue.
messageQueue
messageQueue稱為訊息佇列,用來儲存訊息.它涉及到兩個關鍵操作一個就是將訊息插入訊息佇列,另一個就是讀取訊息並且移除該訊息.
涉及的兩個操作的方法
- enqueueMessage: 插入訊息
- next: 讀取訊息接著移除訊息
這裡重點說下next方法,它是一個無線迴圈的方法,會不斷的從訊息佇列中讀取訊息並且移除,如果此時無訊息,那麼將會一直處於阻塞中.
對於messageQueue暫時瞭解到這裡,接著看Looper,下面還會涉及到訊息佇列.
Looper
Looper稱為訊息迴圈,在訊息機制中扮演著很重要的角色. 不斷的從訊息佇列中獲取新訊息.有訊息就處理,無訊息也一直處於阻塞中.
1. 首先看Looper的構造方法.
對應原始碼
private Looper(boolean quitAllowed) {
//初始化一個訊息佇列
mQueue = new MessageQueue(quitAllowed);
//獲取當前執行緒
mThread = Thread.currentThread();
}
複製程式碼上面looper的構造方法是一個private修飾,所以一般情況不能直接呼叫,系統提供了prepare()方法來建立Looper.
對應原始碼
public static void prepare() {
prepare(true);
}
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {
//說明一個執行緒只能繫結一個looper
throw new RuntimeException("Only one Looper may be created per thread");
}
//將Looper儲存於ThreadLocal中.
sThreadLocal.set(new Looper(quitAllowed));
}
複製程式碼對於主執行緒的特殊性,系統還提供了prepareMainLooper( )來初始化Looper,其主要供ActivityThread使用.並且系統還提供了getMainLooper( )方法,這樣就可以在任何地方獲取主執行緒的looper.
2. 接著看Looper的loop方法.
對應原始碼
public static void loop() {
final Looper me = myLooper();
if (me == null) {
//1.獲取當前執行緒的looper,沒有直接報錯.
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 (;;) {
/*
* 2.呼叫MessageQueue的next獲取訊息.
* (非常重要)
*/
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
final Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
final long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
final long traceTag = me.mTraceTag;
if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
final long end;
try {
//3. (非常重要)呼叫handler分發處理訊息
msg.target.dispatchMessage(msg);
end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
//...省略部分程式碼
}
}
複製程式碼loop方法代表開啟訊息迴圈,具體流程可以看註釋這樣更清晰.這裡特別提一點,需要注意的loop是一個無限迴圈,不斷的從messageQueue中獲取訊息,在之前我們已經瞭解到next獲取訊息時,如果沒有則一直處於阻塞狀態,所以這裡同樣也是處於阻塞狀態.只有當msg為null的時候才會退出,所以在自定義looper時需要在適當的時候,呼叫quit/quitSafely退出looper.也間接的退出了messageQueue.可以看下面原始碼.
對應原始碼
public void quit() {
//呼叫了MessageQueue
mQueue.quit(false);
}
public void quitSafely() {
mQueue.quit(true);
}
複製程式碼另外在分發訊息時,回撥了Handler的dispatchMessage,此方法是在建立handler所使用的Looper中去執行的,而looper又與當前執行緒相繫結的.也就順利的切換到指定執行緒去執行處理任務了.
關於Looper我們分析到這裡,最後總結下Looper幾個比較重要的API.
- Looper.prepare(): 建立looper
- Looper.loop(): 開啟訊息迴圈
- Looper.quit/quitSafely: 立即退出/安全退出
- 當looper退出後,通過handler傳送消失會失敗,send方法會返回false.
handler工作原理
通過前面對MessageQueue與Looper的瞭解,我們可以用一句話總結出三者關係:"Handler依賴Looper(獲取當前執行緒的Looper),而Looper則依賴於MessageQueue(例項化Looper時會同時例項化一個MessageQueue)"
1. handler 準備階段
我們知道Handler依賴於當前執行緒的Looper,而在主執行緒我們並沒有手動建立looper,其實在主執行緒啟動時也就是ActivityThread,已經初始化了一個looper,並且開啟了訊息迴圈.
對應原始碼
public static void main(String[] args) {
//...省略部分程式碼
final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
TrustedCertificateStore.setDefaultUserDirectory(configDir);
Process.setArgV0("<pre-initialized>");
//建立Looper
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
//開啟訊息迴圈
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
複製程式碼如上原始碼,一切準備工作都以就緒,我們就可以盡情使用handler了.
2. handler 傳送階段
當我們建立Handler時,會檢查當前執行緒是否包含Looper.
對應原始碼
public Handler(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());
}
}
//獲取當前執行緒的Looper
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
複製程式碼如果準備工作一切都沒問題,那麼就可以使用handler傳送訊息了.
對應原始碼
//通過Send傳送普通訊息
public final boolean sendMessage(Message msg){
return sendMessageDelayed(msg, 0);
}
//通過Post傳送Runnable訊息
public final boolean post(Runnable r){
return sendMessageDelayed(getPostMessage(r), 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;
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);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
//賦值msg.target=handler.
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
複製程式碼從上面原始碼可知,無論是Send還是Post,最終都是通過send方法將訊息傳送出去,並且傳送訊息僅僅往訊息佇列中插入了一條訊息而已.
3. handler 處理階段
當我們往訊息佇列中插入一條訊息時,此時looper從MessageQueue中獲取到新訊息,就進入訊息處理階段.呼叫了handler的dispatchMessage方法進行處理.
對應原始碼
public void dispatchMessage(Message msg) {
if (msg.callback != null) {//說明是一個Post訊息
//callback為POST方法傳遞的Runnable物件
handleCallback(msg);
} else {//說明是一個普通訊息
if (mCallback != null) { //mCallback是個介面,提供一個建立時不需要派生handler子類.參考構造方法
if (mCallback.handleMessage(msg)) {
return;
}
}
//回撥自身的handleMessage方法
handleMessage(msg);
}
}
複製程式碼最後我們對Hanlder流程做一個總結.
-
handler 準備階段
- 執行緒啟動時,Looper.prepare() 建立一個Looper,通過ThreadLocal將Looper物件和當前執行緒繫結.
- Looper.loop() 方法開啟訊息迴圈,不斷從MessageQueue的中讀取訊息，如沒有訊息，則處於阻塞狀態.
-
handler 傳送階段
-
當Handle建立時，會獲得當前執行緒相關的Looper物件.
-
當通過Handle傳送訊息時,無論是Post還是Send普通訊息,僅僅加入一條訊息到MessageQueue.
-
looper通過MessageQueue的next方法獲取新訊息後,然後處理這個訊息,最終looper會交由Handler的dispatchMessage方法.
-
-
handler 處理階段
-
如果是Post訊息,則回撥Runnable的run方法.
-
如果是普通訊息,則回撥mCallback的handleMessage或自身的HandleMessage方法.
-
三. 在自定義Thread中使用hanlder
此外通過以上流程分析,我們可以知道如果在某些特殊情況需要在子執行緒使用handler.那麼只需要為其執行緒建立looper,開啟訊息迴圈.這樣再其他地方傳送的訊息都將在此執行緒中執行.
示例程式碼
//虛擬碼
new Thread(){
@Override
public void run() {
Looper.prepare();
Handler handler = new Handler();
Looper.loop();
}
}.start();
複製程式碼四. Handler機制的擴充套件
為了更加方便使用Handler,Androi系統提供了兩種方式.具體使用筆記簡單就不講述了,直接看原始碼.
- Activity.runOnUiThread(Runnable)
對應原始碼
public final void runOnUiThread(Runnable action) {
if (Thread.currentThread() != mUiThread) {
//傳送Post訊息
mHandler.post(action);
} else {
//直接執行任務
action.run();
}
}
複製程式碼- View.post(Runnable)
對應原始碼
public boolean post(Runnable action) {
final AttachInfo attachInfo = mAttachInfo;
if (attachInfo != null) {
//直接通過handler傳送Post訊息
return attachInfo.mHandler.post(action);
}
//先加入佇列,等attachInfo被賦值時,會通過handler傳送訊息.
getRunQueue().post(action);
return true;
}
複製程式碼最後用一張Handler工作原理圖結束本文.
由於本人技術有限,如有錯誤的地方,麻煩大家給我提出來,本人不勝感激,大家一起學習進步.
參考連結: