Android異步處理三:Handler+Looper+MessageQueue深入詳解

在《Android異步處理一:使用Thread+Handler實現非UI線程更新UI界面》/kf/201204/127128.html中,我們講到使用Thread+Handler的方式來實現界面的更新,其實是在非UI線程發送消息到UI線程,通知UI線程進行界面更新,這一篇我們將深入學習Android線程間通訊的實現原理。
概述:Android使用消息機制實現線程間的通信,線程通過Looper建立自己的消息循環,MessageQueue是FIFO的消息隊列,Looper負責從MessageQueue中取出消息,並且分發到消息指定目標Handler對象。Handler對象綁定到線程的局部變量Looper,封裝瞭發送消息和處理消息的接口。
例子:在介紹原理之前,我們先介紹Android線程通訊的一個例子,這個例子實現點擊按鈕之後從主線程發送消息"hello"到另外一個名為” CustomThread”的線程。
代碼下載
LooperThreadActivity.java
[java]
1. package com.zhuozhuo; 
2.  
3. import android.app.Activity; 
4. import android.os.Bundle; 
5. import android.os.Handler; 
6. import android.os.Looper; 
7. import android.os.Message; 
8. import android.util.Log; 
9. import android.view.View; 
10. import android.view.View.OnClickListener; 
11.  
12. public class LooperThreadActivity extends Activity{ 
13.     /** Called when the activity is first created. */ 
14.      
15.     private final int MSG_HELLO = 0; 
16.     private Handler mHandler; 
17.      
18.     @Override 
19.     public void onCreate(Bundle savedInstanceState) { 
20.         super.onCreate(savedInstanceState); 
21.         setContentView(R.layout.main); 
22.         new CustomThread().start();//新建並啟動CustomThread實例  
23.          
24.         findViewById(R.id.send_btn).setOnClickListener(new OnClickListener() { 
25.              
26.             @Override 
27.             public void onClick(View v) {//點擊界面時發送消息  
28.                 String str = "hello"; 
29.                 Log.d("Test", "MainThread is ready to send msg:" + str); 
30.                 mHandler.obtainMessage(MSG_HELLO, str).sendToTarget();//發送消息到CustomThread實例  
31.                  
32.             } 
33.         }); 
34.          
35.     } 
36.      
37.      
38.      
39.      
40.      
41.     class CustomThread extends Thread { 
42.         @Override 
43.         public void run() { 
44.             //建立消息循環的步驟  
45.             Looper.prepare();//1、初始化Looper  
46.             mHandler = new Handler(){//2、綁定handler到CustomThread實例的Looper對象  
47.                 public void handleMessage (Message msg) {//3、定義處理消息的方法  
48.                     switch(msg.what) { 
49.                     case MSG_HELLO: 
50.                         Log.d("Test", "CustomThread receive msg:" + (String) msg.obj); 
51.                     } 
52.                 } 
53.             }; 
54.             Looper.loop();//4、啟動消息循環  
55.         } 
56.     } 
57. } 
 main.xml
[html]
1. <?xml version="1.0" encoding="utf-8"?> 
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
3.     android:orientation="vertical" 
4.     android:layout_width="fill_parent" 
5.     android:layout_height="fill_parent" 
6.     > 
7. <TextView   
8.     android:layout_width="fill_parent"  
9.     android:layout_height="wrap_content"  
10.     android:text="@string/hello" 
11.     /> 
12. <Button android:text="發送消息" android:id="@+id/send_btn" android:layout_width="wrap_content" android:layout_height="wrap_content"></Button> 
13. </LinearLayout> 
 
Log打印結果:
 
原理:
我們看到,為一個線程建立消息循環有四個步驟:
1、  初始化Looper
2、  綁定handler到CustomThread實例的Looper對象
3、  定義處理消息的方法
4、  啟動消息循環
下面我們以這個例子為線索,深入Android源代碼,說明Android Framework是如何建立消息循環,並對消息進行分發的。
1、  初始化Looper : Looper.prepare()
Looper.java
[java]
1. private static final ThreadLocal sThreadLocal = new ThreadLocal(); 
2. public static final void prepare() { 
3.         if (sThreadLocal.get() != null) { 
4.             throw new RuntimeException("Only one Looper may be created per thread"); 
5.         } 
6.         sThreadLocal.set(new Looper()); 
7. } 
 
一個線程在調用Looper的靜態方法prepare()時,這個線程會新建一個Looper對象,並放入到線程的局部變量中,而這個變量是不和其他線程共享的(關於ThreadLocal的介紹)。下面我們看看Looper()這個構造函數:
Looper.java
[java]
1. final MessageQueue mQueue; 
2. private Looper() { 
3.         mQueue = new MessageQueue(); 
4.         mRun = true; 
5.         mThread = Thread.currentThread(); 
6.     } 
 
可以看到在Looper的構造函數中,創建瞭一個消息隊列對象mQueue,此時,調用Looper. prepare()的線程就建立起一個消息循環的對象(此時還沒開始進行消息循環)。
2、  綁定handler到CustomThread實例的Looper對象 : mHandler= new Handler()
Handler.java
[java]
1. final MessageQueue mQueue; 
2.  final Looper mLooper; 
3. public Handler() { 
4.         if (FIND_POTENTIAL_LEAKS) { 
5.             final Class<? extends Handler> klass = getClass(); 
6.             if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) && 
7.                     (klass.getModifiers() & Modifier.STATIC) == 0) { 
8.                 Log.w(TAG, "The following Handler class should be static or leaks might occur: " + 
9.                     klass.getCanonicalName()); 
10.             } 
11.         } 
12.  
13.         mLooper = Looper.myLooper(); 
14.         if (mLooper == null) { 
15.             throw new RuntimeException( 
16.                 "Can't create handler inside thread that has not called Looper.prepare()"); 
17.         } 
18.         mQueue = mLooper.mQueue; 
19.         mCallback = null; 
20. } 
 
Handler通過mLooper = Looper.myLooper();綁定到線程的局部變量Looper上去,同時Handler通過mQueue =mLooper.mQueue;獲得線程的消息隊列。此時,Handler就綁定到創建此Handler對象的線程的消息隊列上瞭。
3、定義處理消息的方法:Override public void handleMessage (Message msg){}
     子類需要覆蓋這個方法,實現接受到消息後的處理方法。
4、啟動消息循環 : Looper.loop()
      所有準備工作都準備好瞭,是時候啟動消息循環瞭!Looper的靜態方法loop()實現瞭消息循環。
Looper.java
[java]
1. public static final void loop() { 
2.        Looper me = myLooper(); 
3.        MessageQueue queue = me.mQueue; 
4.         
5.        // Make sure the identity of this thread is that of the local process,  
6.        // and keep track of what that identity token actually is.  
7.        Binder.clearCallingIdentity(); 
8.        final long ident = Binder.clearCallingIdentity(); 
9.         
10.        while (true) { 
11.            Message msg = queue.next(); // might block  
12.            //if (!me.mRun) {  
13.            //    break;  
14.            //}  
15.            if (msg != null) { 
16.                if (msg.target == null) { 
17.                    // No target is a magic identifier for the quit message.  
18.                    return; 
19.                } 
20.                if (me.mLogging!= null) me.mLogging.println( 
21.                        ">>>>> Dispatching to " + msg.target + " " 
22.                        + msg.callback + ": " + msg.what 
23.                        ); 
24.                msg.target.dispatchMessage(msg); 
25.                if (me.mLogging!= null) me.mLogging.println( 
26.                        "<<<<< Finished to    " + msg.target + " " 
27.                        + msg.callback); 
28.                 
29.                // Make sure that during the course of dispatching the  
30.                // identity of the thread wasn't corrupted.  
31.                final long newIdent = Binder.clearCallingIdentity(); 
32.                if (ident != newIdent) { 
33.                    Log.wtf("Looper", "Thread identity changed from 0x" 
34.                            + Long.toHexString(ident) + " to 0x" 
35.                            + Long.toHexString(newIdent) + " while dispatching to " 
36.                            + msg.target.getClass().getName() + " " 
37.                            + msg.callback + " what=" + msg.what); 
38.                } 
39.                 
40.                msg.recycle(); 
41.            } 
42.        } 
43.    } 
 
while(true)體現瞭消息循環中的“循環“,Looper會在循環體中調用queue.next()獲取消息隊列中需要處理的下一條消息。當msg != null且msg.target != null時,調用msg.target.dispatchMessage(msg);分發消息,當分發完成後,調用msg.recycle();回收消息。
msg.target是一個handler對象,表示需要處理這個消息的handler對象。Handler的void dispatchMessage(Message msg)方法如下:
Handler.java
[java]
1. public void dispatchMessage(Message msg) { 
2.         if (msg.callback != null) { 
3.             handleCallback(msg); 
4.         } else { 
5.             if (mCallback != null) { 
6.                 if (mCallback.handleMessage(msg)) { 
7.                     return; 
8.                 } 
9.             } 
10.             handleMessage(msg); 
11.         } 
12. } 
 
可見,當msg.callback== null 並且mCallback == null時,這個例子是由handleMessage(msg);處理消息,上面我們說到子類覆蓋這個方法可以實現消息的具體處理過程。

總結:從上面的分析過程可知,消息循環的核心是Looper,Looper持有消息隊列MessageQueue對象,一個線程可以把Looper設為該線程的局部變量,這就相當於這個線程建立瞭一個對應的消息隊列。Handler的作用就是封裝發送消息和處理消息的過程,讓其他線程隻需要操作Handler就可以發消息給創建Handler的線程。由此可以知道,在上一篇《Android異步處理一:使用Thread+Handler實現非UI線程更新UI界面》/kf/201204/127128.html中,UI線程在創建的時候就建立瞭消息循環(在ActivityThread的public static final void main(String[] args)方法中實現),因此我們可以在其他線程給UI線程的handler發送消息,達到更新UI的目的。

 
摘自  lzc的專欄

發佈留言

發佈留言必須填寫的電子郵件地址不會公開。 必填欄位標示為 *