Android----Thread+Handler 線程 訊息迴圈(轉載)

標籤：

近來找了一些關於android線程間通訊的資料，整理學習了一下，並製作了一個簡單的例子。 

　andriod提供了 Handler 和 Looper 來滿足線程間的通訊。例如一個子線程從網路上下載了一副圖片，當它下載完成後會發送訊息給主線程，這個訊息是通過綁定在主線程的Handler來傳遞的。 

在Android，這裡的線程分為有訊息迴圈的線程和沒有訊息迴圈的線程，有訊息迴圈的線程一般都會有一個Looper，這個事android的新 概念。我們的主線程（UI線程）就是一個訊息迴圈的線程。針對這種訊息迴圈的機制，我們引入一個新的機制Handle，我們有訊息迴圈，就要往訊息迴圈裡 面發送相應的訊息，自訂訊息一般都會有自己對應的處理，訊息的發送和清除，訊息的的處理，把這些都封裝在Handle裡面，注意Handle只是針對那 些有Looper的線程，不管是UI線程還是子線程，只要你有Looper，我就可以往你的訊息佇列裡面添加東西，並做相應的處理。 
但是這裡還有一點，就是只要是關於UI相關的東西，就不能放在子線程中，因為子線程是不能操作UI的，只能進行資料、系統等其他非UI的操作。 
　　在Android，這裡的線程分為有訊息迴圈的線程和沒有訊息迴圈的線程，有訊息迴圈的線程一般都會有一個Looper，這個是android的新概念。我們的主線程（UI線程）就是一個訊息迴圈的線程。針對這種訊息迴圈的機制，我們引入一個新的機制Handler，我們有訊息迴圈，就要往訊息迴圈裡面發送相應的訊息，自訂訊息一般都會有自己對應的處理，訊息的發送和清除，把這些都封裝在Handler裡面，注意Handler只是針對那 些有Looper的線程，不管是UI線程還是子線程，只要你有Looper，我就可以往你的訊息佇列裡面添加東西，並做相應的處理。 

但是這裡還有一點，就是只要是關於UI相關的東西，就不能放在子線程中，因為子線程是不能操作UI的，只能進行資料、系統等其他非UI的操作。 


　　一個Handler的建立它就會被綁定到這個線程的訊息佇列中，如果是在主線程建立的，那就不需要寫代碼來建立訊息佇列了，預設的訊息佇列會在主線程被建立。但是如果是在子線程的話，就必須在建立Handler之前先初始化線程的訊息佇列。如下面的代碼： 

Java代碼  

1. class ChildThread extends Thread {  
2.   
3.     public void run() {  
4.   
5.         /* 
6.          * 建立 handler前先初始化Looper. 
7.          */  
8.         Looper.prepare();  
9.   
10.         /* 
11.          * 在子線程建立handler，所以會綁定到子線程的訊息佇列中 
12.          * 
13.          */  
14.         mChildHandler = new Handler() {  
15.   
16.             public void handleMessage(Message msg) {  
17.   
18.                 /* 
19.                  * Do some expensive operations there. 
20.                  */  
21.             }  
22.         };  
23.   
24.         /* 
25.          * 啟動該線程的訊息佇列 
26.          */  
27.         Looper.loop();  
28.     }  
29. }  

 



當Handler收到訊息後，就會運行handleMessage(…)的回呼函數，可以在裡面做一些耗時的操作。 




最後完成了操作要結束子線程時，記得調用quit()來結束訊息迴圈隊列。 

mChildHandler.getLooper().quit(); 



下面是一個線程間通訊的小例子： 

Java代碼  

1. /** 
2.  *  
3.  * @author allin.dev  
4.  * http://allin.cnblogs.com 
5.  *  
6.  */  
7. public class MainThread extends Activity {  
8.   
9.     private static final String TAG = "MainThread";  
10.     private Handler mMainHandler, mChildHandler;  
11.     private TextView info;  
12.     private Button msgBtn;  
13.   
14.     @Override  
15.     public void onCreate(Bundle savedInstanceState) {  
16.         super.onCreate(savedInstanceState);  
17.         setContentView(R.layout.main);  
18.   
19.         info = (TextView) findViewById(R.id.info);  
20.         msgBtn = (Button) findViewById(R.id.msgBtn);  
21.   
22.         mMainHandler = new Handler() {  
23.   
24.             @Override  
25.             public void handleMessage(Message msg) {  
26.                 Log.i(TAG, "Got an incoming message from the child thread - "  
27.                         + (String) msg.obj);  
28.                 // 接收子線程的訊息  
29.                 info.setText((String) msg.obj);  
30.             }  
31.   
32.         };  
33.   
34.         new ChildThread().start();  
35.           
36.           
37.         msgBtn.setOnClickListener(new OnClickListener() {  
38.   
39.             @Override  
40.             public void onClick(View v) {  
41.                   
42.                 if (mChildHandler != null) {  
43.                       
44.                     //發送訊息給子線程  
45.                     Message childMsg = mChildHandler.obtainMessage();  
46.                     childMsg.obj = mMainHandler.getLooper().getThread().getName() + " says Hello";  
47.                     mChildHandler.sendMessage(childMsg);  
48.                       
49.                     Log.i(TAG, "Send a message to the child thread - " + (String)childMsg.obj);  
50.   
51.   
52.                 }  
53.             }  
54.         });  
55.   
56.     }  
57.   
58.     public void onDestroy() {  
59. 　　　　　　super.onDestroy();  
60.         Log.i(TAG, "Stop looping the child thread‘s message queue");  
61.   
62.         mChildHandler.getLooper().quit();  
63.     }  
64.   
65.     class ChildThread extends Thread {  
66.   
67.         private static final String CHILD_TAG = "ChildThread";  
68.   
69.         public void run() {  
70.             this.setName("ChildThread");  
71.   
72.             //初始化訊息迴圈隊列，需要在Handler建立之前  
73.             Looper.prepare();  
74.   
75.             mChildHandler = new Handler() {  
76.                 @Override  
77.                 public void handleMessage(Message msg) {  
78.                      Log.i(CHILD_TAG, "Got an incoming message from the main thread - " + (String)msg.obj);  
79.   
80.   
81.                     try {  
82.   
83.                         //在子線程中可以做一些耗時的工作  
84.                         sleep(100);  
85.   
86.                         Message toMain = mMainHandler.obtainMessage();  
87.                         toMain.obj = "This is " + this.getLooper().getThread().getName() +  
88.                                     ".  Did you send me \"" + (String)msg.obj + "\"?";  
89.   
90.                         mMainHandler.sendMessage(toMain);  
91.   
92.                         Log.i(CHILD_TAG, "Send a message to the main thread - " + (String)toMain.obj);  
93.   
94.                     } catch (InterruptedException e) {  
95.                         // TODO Auto-generated catch block  
96.                         e.printStackTrace();  
97.                     }  
98.                 }  
99.   
100.             };  
101.   
102.             Log.i(CHILD_TAG, "Child handler is bound to - "+ mChildHandler.getLooper().getThread().getName());  
103.   
104.             //啟動子線程訊息迴圈隊列  
105.             Looper.loop();  
106.         }  
107.     }  
108. }  

 

Android----Thread+Handler 線程 訊息迴圈(轉載)