不忘初心 砥礪前行, Tomorrow Is Another Day !html
本文概要:android
前言:安全
Android的消息機制主要是指Handler運行機制,handler它的做用就是切換到指定線程執行任務,記住是切換到指定線程執行任務,能夠子線程也能夠是主線程,只是在實際開發中常常應用於更新UI.在handler底層須要MessageQueue與Looper支持.接着咱們來具體介紹.bash
爲了不多線程,更新UI線程是不安全的.
複製代碼
鎖機制會形成邏輯複雜而且下降訪問UI的效率,阻塞某些線程的執行.
複製代碼
對於ThreadLocal若是暫不瞭解,能夠先閱讀三. 線程管理之ThreadLocal,這樣更容易理解Handler消息機制.多線程
接下來咱們看三劍客的各自工做原理,首先看messageQueue.async
messageQueue
messageQueue稱爲消息隊列,用來存儲消息.它涉及到兩個關鍵操做一個就是將消息插入消息隊列,另外一個就是讀取消息而且移除該消息.ide
涉及的兩個操做的方法oop
這裏重點說下next方法,它是一個無線循環的方法,會不斷的從消息隊列中讀取消息而且移除,若是此時無消息,那麼將會一直處於阻塞中.post
對於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.
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流程作一個總結.
當Handle建立時,會得到當前線程相關的Looper對象.
當經過Handle發送消息時,不管是Post仍是Send普通消息,僅僅加入一條消息到MessageQueue.
looper經過MessageQueue的next方法獲取新消息後,而後處理這個消息,最終looper會交由Handler的dispatchMessage方法.
若是是Post消息,則回調Runnable的run方法.
若是是普通消息,則回調mCallback的handleMessage或自身的HandleMessage方法.
此外經過以上流程分析,咱們能夠知道若是在某些特殊狀況須要在子線程使用handler.那麼只須要爲其線程建立looper,開啓消息循環.這樣再其餘地方發送的消息都將在此線程中執行.
示例代碼
//僞代碼
new Thread(){
@Override
public void run() {
Looper.prepare();
Handler handler = new Handler();
Looper.loop();
}
}.start();
複製代碼
爲了更加方便使用Handler,Androi系統提供了兩種方式.具體使用筆記簡單就不講述了,直接看源碼.
對應源碼
public final void runOnUiThread(Runnable action) {
if (Thread.currentThread() != mUiThread) {
//發送Post消息
mHandler.post(action);
} else {
//直接執行任務
action.run();
}
}
複製代碼
對應源碼
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工做原理圖結束本文.
因爲本人技術有限,若有錯誤的地方,麻煩你們給我提出來,本人不勝感激,你們一塊兒學習進步.
參考連接: