android的消息處理機制——Looper,Handler,Message
這篇文章有一半是copy別人的，站在巨人的肩膀上，咱們才能看得更高更遠......java
在開始討論android的消息處理機制前，先來談談一些基本相關的術語。android
通訊的同步（Synchronous）：指向客戶端發送請求後，必需要在服務端有迴應後客戶端才繼續發送其它的請求，因此這時全部請求將會在服務端獲得同步，直到服務端返回請求。web
通訊的異步（Asynchronous）：指客戶端在發送請求後，沒必要等待服務端的迴應就能夠發送下一個請求。app
所謂同步調用，就是在一個函數或方法調用時，沒有獲得結果以前，該調用就不返回，直到返回結果。異步調用和同步是相對的，在一個異步調用發起後，被調用者當即返回給調用者，可是調用者不能馬上獲得結果，被調用都在實際處理這個調用的請求完成後，經過狀態、通知或回調等方式來通知調用者請求處理的結果。異步
android的消息處理有三個核心類：Looper,Handler和Message。其實還有一Message Queue（消息隊列），可是MQ被封裝到Looper裏面了，咱們不會直接與MQ打交道，因此它不算是個核心類。ide
1. 消息類：Message類函數
android.os.Message的主要功能是進行消息的封裝，同時能夠指定消息的操做形式，Message類定義的變量和經常使用方法以下：oop
（1）public int what：變量，用於定義此Message屬於何種操做源碼分析
（2）public Object obj：變量，用於定義此Message傳遞的信息數據，經過它傳遞信息post
（3）public int arg1：變量，傳遞一些整型數據時使用
（4）public int arg2：變量，傳遞一些整型數據時使用
（5）public Handler getTarget()：普通方法，取得操做此消息的Handler對象。
在整個消息處理機制中，message又叫task，封裝了任務攜帶的信息和處理該任務的handler。message的用法比較簡單，可是有這麼幾點須要注意：
（1）儘管Message有public的默認構造方法，可是你應該經過Message.obtain()來從消息池中得到空消息對象，以節省資源。
（2）若是你的message只須要攜帶簡單的int信息，請優先使用Message.arg1和Message.arg2來傳遞信息，這比用Bundle更省內存
（3）擅用message.what來標識信息，以便用不一樣方式處理message。
2. 消息通道：Looper
在使用Handler處理Message時，須要Looper（通道）來完成。在一個Activity中，系統會自動幫用戶啓動Looper對象，而在一個用戶自定義的類中，則須要用戶手工調用Looper類中的方法，而後才能夠正常啓動Looper對象。Looper的字面意思是「循環者」，它被設計用來使一個普通線程變成Looper線程。所謂Looper線程就是循環工做的線程。在程序開發中（尤爲是GUI開發中），咱們常常會須要一個線程不斷循環，一旦有新任務則執行，執行完繼續等待下一個任務，這就是Looper線程。使用Looper類建立Looper線程很簡單：
public class LooperThread extends Thread {
@Override
public void run() {
// 將當前線程初始化爲Looper線程
Looper.prepare();
// ...其餘處理，如實例化handler
// 開始循環處理消息隊列
Looper.loop();
}
}
經過上面兩行核心代碼，你的線程就升級爲Looper線程了！那麼這兩行代碼都作了些什麼呢？
1)Looper.prepare()
經過上圖能夠看到，如今你的線程中有一個Looper對象，它的內部維護了一個消息隊列MQ。注意，一個Thread只能有一個Looper對象，爲何呢？來看一下源碼
public class Looper {
// 每一個線程中的Looper對象實際上是一個ThreadLocal，即線程本地存儲(TLS)對象
private static final ThreadLocal sThreadLocal = new ThreadLocal();
// Looper內的消息隊列
final MessageQueue mQueue;
// 當前線程
Thread mThread;
//其餘屬性
// 每一個Looper對象中有它的消息隊列，和它所屬的線程
private Looper() {
mQueue = new MessageQueue();
mRun = true;
mThread = Thread.currentThread();
}
// 咱們調用該方法會在調用線程的TLS中建立Looper對象
public static final void prepare() {
if (sThreadLocal.get() != null) {
// 試圖在有Looper的線程中再次建立Looper將拋出異常
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper());
}
// 其餘方法
}
prepare()背後的工做方式一目瞭然，其核心就是將looper對象定義爲ThreadLocal。
2）Looper.loop()
調用loop方法後，Looper線程就開始真正工做了，它不斷從本身的MQ中取出隊頭的消息(也叫任務)執行。其源碼分析以下：
public static final void loop() {
Looper me = myLooper(); //獲得當前線程Looper
MessageQueue queue = me.mQueue; //獲得當前looper的MQ
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
// 開始循環
while (true) {
Message msg = queue.next(); // 取出message
if (msg != null) {
if (msg.target == null) {
// message沒有target爲結束信號，退出循環
return;
}
// 日誌
if (me.mLogging!= null) me.mLogging.println(
">>>>> Dispatching to " + msg.target + " "
+ msg.callback + ": " + msg.what
);
// 很是重要！將真正的處理工做交給message的target，即後面要講的handler
msg.target.dispatchMessage(msg);
// 日誌
if (me.mLogging!= null) me.mLogging.println(
"<<<<< Finished to " + msg.target + " "
+ msg.callback);
final long newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
Log.wtf("Looper", "Thread identity changed from 0x"
+ Long.toHexString(ident) + " to 0x"
+ Long.toHexString(newIdent) + " while dispatching to "
+ msg.target.getClass().getName() + " "
+ msg.callback + " what=" + msg.what);
}
// 回收message資源
msg.recycle();
}
}
}
除了prepare()和loop()方法，Looper類還提供了一些有用的方法，好比Looper.myLooper()獲得當前線程looper對象：
public static final Looper myLooper() {
// 在任意線程調用Looper.myLooper()返回的都是那個線程的looper
return (Looper)sThreadLocal.get();
}
getThread()獲得looper對象所屬線程：
public Thread getThread() {
return mThread;
}
quit()方法結束looper循環：
public void quit() {
// 建立一個空的message，它的target爲NULL，表示結束循環消息
Message msg = Message.obtain();
// 發出消息
mQueue.enqueueMessage(msg, 0);
}
綜上，Looper有如下幾個要點：
1）每一個線程有且只能有一個Looper對象，它是一個ThreadLocal
2）Looper內部有一個消息隊列，loop()方法調用後線程開始不斷從隊列中取出消息執行
3）Looper使一個線程變成Looper線程。
那麼，咱們如何操做Message Queue上的消息呢？這就是Handler的用處了
3. 消息操做類：Handler類
Message對象封裝了全部的消息，而這些消息的操做須要android.os.Handler類完成。什麼是handler？handler起到了處理MQ上的消息的做用（只處理由本身發出的消息），即通知MQ它要執行一個任務(sendMessage)，並在loop到本身的時候執行該任務(handleMessage)，整個過程是異步的。handler建立時會關聯一個looper，默認的構造方法將關聯當前線程的looper，不過這也是能夠set的。默認的構造方法：
public class handler {
final MessageQueue mQueue; // 關聯的MQ
final Looper mLooper; // 關聯的looper
final Callback mCallback;
// 其餘屬性
public Handler() {
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();
// looper不能爲空，即該默認的構造方法只能在looper線程中使用
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
// 重要！！！直接把關聯looper的MQ做爲本身的MQ，所以它的消息將發送到關聯looper的MQ上
mQueue = mLooper.mQueue;
mCallback = null;
}
// 其餘方法
}
下面咱們就能夠爲以前的LooperThread類加入Handler：
public class LooperThread extends Thread {
private Handler handler1;
private Handler handler2;
@Override
public void run() {
// 將當前線程初始化爲Looper線程
Looper.prepare();
// 實例化兩個handler
handler1 = new Handler();
handler2 = new Handler();
// 開始循環處理消息隊列
Looper.loop();
}
}
加入handler後的效果以下圖：
能夠看到，一個線程能夠有多個Handler，可是隻能有一個Looper！
Handler發送消息
有了handler以後，咱們就可使用
post(Runnable)
postAtTime(Runnable, long)
postDelayed(Runnable, long)
sendEmptyMessage(int)
sendMessage(Message)
sendMessageAtTime(Message, long)
sendMessageDelayed(Message, long)
這些方法向MQ上發送消息了。光看這些API你可能會以爲handler能發兩種消息，一種是Runnable對象，一種是message對象，這是直觀的理解，但其實post發出的Runnable對象最後都被封裝成message對象了，見源碼：
// 此方法用於向關聯的MQ上發送Runnable對象，它的run方法將在handler關聯的looper線程中執行
public final boolean post(Runnable r)
{
// 注意getPostMessage(r)將runnable封裝成message
return sendMessageDelayed(getPostMessage(r), 0);
}
private final Message getPostMessage(Runnable r) {
Message m = Message.obtain(); //獲得空的message
m.callback = r; //將runnable設爲message的callback，
return m;
}
public boolean sendMessageAtTime(Message msg, long uptimeMillis)
{
boolean sent = false;
MessageQueue queue = mQueue;
if (queue != null) {
msg.target = this; // message的target必須設爲該handler！
sent = queue.enqueueMessage(msg, uptimeMillis);
}
else {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
}
return sent;
}
經過handler發出的message有以下特色：
1.message.target爲該handler對象，這確保了looper執行到該message時能找處處理它的handler，即loop()方法中的關鍵代碼
msg.target.dispatchMessage(msg);
2.post發出的message，其callback爲Runnable對象
Handler處理消息
說完了消息的發送，再來看下handler如何處理消息。消息的處理是經過核心方法dispatchMessage(Message msg)與鉤子方法handleMessage(Message msg)
完成的，見源碼
dispatchMessage(Message msg) {
(msg.callback != ) {
handleCallback(msg);
} {
(mCallback != ) {
(mCallback.handleMessage(msg)) {
;
}
}
handleMessage(msg);
}
}
handleCallback(Message message) {
message.callback.run(); }
handleMessage(Message msg) {
}
能夠看到，除了handleMessage(Message msg)和Runnable對象的run方法由開發者實現外（實現具體邏輯），handler的內部工做機制對開發者是透明的。Handler擁有下面兩個重要的特色：
1)handler能夠在任意線程發送消息，這些消息會被添加到關聯的MQ上
2)消息的處理是經過核心方法dispatchMessage(Message msg)與鉤子方法handleMessage(Message msg)完成的，handler是在它關聯的looper線程中處理消息的。
這就解決了android最經典的不能在其餘非主線程中更新UI的問題。android的主線程也是一個looper線程(looper在android中運用很廣)，咱們在其中建立的handler默認將關聯主線程MQ。所以，利用handler的一個solution就是在activity中建立handler並將其引用傳遞給worker thread，worker thread執行完任務後使用handler發送消息通知activity更新UI。(過程如圖)
下面給出sample代碼，僅供參考：
TestDriverActivity Activity {
TextView textview;
@Override
onCreate(Bundle savedInstanceState) {
.onCreate(savedInstanceState);
setContentView(R.layout.main);
textview = (TextView) findViewById(R.id.textview);
Thread workerThread = Thread( SampleTask( MyHandler()));
workerThread.start();
}
appendText(String msg) {
textview.setText(textview.getText() + "\n" + msg);
}
MyHandler Handler {
@Override
handleMessage(Message msg) {
String result = msg.getData().getString("message");
appendText(result);
}
}
}
SampleTask Runnable {
String TAG = SampleTask..getSimpleName();
Handler handler;
SampleTask(Handler handler) {
();
.handler = handler;
}
@Override
run() {
{ Thread.sleep(5000);
Message msg = prepareMessage("task completed!");
handler.sendMessage(msg);
} (InterruptedException e) {
Log.d(TAG, "interrupted!");
}
}
Message prepareMessage(String str) {
Message result = handler.obtainMessage();
Bundle data = Bundle();
data.putString("message", str);
result.setData(data);
result;
}
}
- 1. Android 消息機制（Handler，Looper，MessageQueue，Message）
- 2. android的消息處理機制——Looper,Handler,Message （原理圖、源碼）
- 3. android的消息處理機制（圖+源碼分析）——Looper,Handler,Message
- 4. Android的消息處理機制（圖+源碼分析）——Looper,Handler,Message
- 5. Android的消息處理機制——Handler、Looper和Message
- 6. Android消息處理機制（Handler，Looper，MessageQueue和Message）
- 7. Android消息處理機制(Handler、Looper、MessageQueue與Message)
- 8. Android消息處理機制——Looper,Handler,Message,MessageQueue,Thread
- 9. Android 消息處理機制（Looper、Handler、MessageQueue,Message）
- 10. Android消息處理機制(Handler 與Message)
- 更多相關文章...
- • HTTP 消息結構 - HTTP 教程
- • TiDB數據庫的管理機制 - NoSQL教程
- • 漫談MySQL的鎖機制
- • Docker容器實戰(六) - 容器的隔離與限制
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. vs2019運行opencv圖片顯示代碼時，窗口亂碼
- 2. app自動化 - 元素定位不到？別慌，看完你就能解決
- 3. 在Win8下用cisco ××× Client連接時報Reason 422錯誤的解決方法
- 4. eclipse快速補全代碼
- 5. Eclipse中Java/Html/Css/Jsp/JavaScript等代碼的格式化
- 6. idea+spring boot +mabitys(wanglezapin)+mysql (1)
- 7. 勒索病毒發生變種 新文件名將帶有「.UIWIX」後綴
- 8. 【原創】Python 源文件編碼解讀
- 9. iOS9企業部署分發問題深入瞭解與解決
- 10. 安裝pytorch報錯CondaHTTPError：******
- 1. Android 消息機制（Handler，Looper，MessageQueue，Message）
- 2. android的消息處理機制——Looper,Handler,Message （原理圖、源碼）
- 3. android的消息處理機制（圖+源碼分析）——Looper,Handler,Message
- 4. Android的消息處理機制（圖+源碼分析）——Looper,Handler,Message
- 5. Android的消息處理機制——Handler、Looper和Message
- 6. Android消息處理機制（Handler，Looper，MessageQueue和Message）
- 7. Android消息處理機制(Handler、Looper、MessageQueue與Message)
- 8. Android消息處理機制——Looper,Handler,Message,MessageQueue,Thread
- 9. Android 消息處理機制（Looper、Handler、MessageQueue,Message）
- 10. Android消息處理機制(Handler 與Message)