Android中Handler的使用方法及實例（基礎回顧）

Handler使用例1

這個例子是最簡單的介紹handler使用的,是將handler綁定到它所創建的線程中.
本次實驗完成的功能是:單擊Start按鈕，程序會開始啓動線程，而且線程程序完成後延時1s會繼續啓動該線程，每次線程的run函數中完成對界面輸出nUpdateThread...文字，不停的運行下去，當單擊End按鈕時，該線程就會中止，若是繼續單擊Start，則文字又開始輸出了。

軟件界面以下：


實驗主要部分代碼和註釋：

MainActivity.java:

 1 package com.example.handler1; 
 2 import android.app.Activity;
 3 import android.os.Bundle;
 4 import android.os.Handler;
 5 import android.view.Menu;
 6 import android.view.View;
 7 import android.view.View.OnClickListener;
 8 import android.widget.Button;
 9 import android.widget.TextView;
10 
11 public class MainActivity extends Activity {
12 
13     private TextView text_view = null;
14     private Button start = null;
15     private Button end = null;
16 
17     //使用handler時首先要建立一個handler
18     Handler handler = new Handler();
19     //要用handler來處理多線程能夠使用runnable接口，這裏先定義該接口
20     //線程中運行該接口的run函數
21     Runnable update_thread = new Runnable()
22     {
23         public void run()
24         {
25             //線程每次執行時輸出"UpdateThread..."文字,且自動換行
26             //textview的append功能和Qt中的append相似，不會覆蓋前面
27             //的內容，只是Qt中的append默認是自動換行模式
28             text_view.append("\nUpdateThread...");
29             //延時1s後又將線程加入到線程隊列中
30             handler.postDelayed(update_thread, 1000);
31 
32         }
33     };
34 
35     @Override
36     public void onCreate(Bundle savedInstanceState) {
37         super.onCreate(savedInstanceState);
38         setContentView(R.layout.activity_main);
39 
40         text_view = (TextView)findViewById(R.id.text_view);
41         start = (Button)findViewById(R.id.start);
42         start.setOnClickListener(new StartClickListener());
43         end = (Button)findViewById(R.id.end);
44         end.setOnClickListener(new EndClickListener());
45 
46     }
47 
48     private class StartClickListener implements OnClickListener
49     {
50         public void onClick(View v) {
51             // TODO Auto-generated method stub
52             //將線程接口馬上送到線程隊列中
53             handler.post(update_thread);
54         }                
55     }
56 
57     private class EndClickListener implements OnClickListener
58     {
59 
60         public void onClick(View v) {
61             // TODO Auto-generated method stub
62             //將接口從線程隊列中移除
63             handler.removeCallbacks(update_thread);
64         }
65 
66     }
67 
68     @Override
69     public boolean onCreateOptionsMenu(Menu menu) {
70         getMenuInflater().inflate(R.menu.activity_main, menu);
71         return true;
72     }
73 }

activity_main.xml:

 1 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 2     xmlns:tools="http://schemas.android.com/tools"
 3     android:layout_width="match_parent"
 4     android:layout_height="match_parent"
 5     android:orientation="vertical" >
 6  
 7 
 8     <TextView
 9         android:id="@+id/text_view"
10         android:layout_width="fill_parent"
11         android:layout_height="200dip"
12         android:text="@string/hello_world"
13         tools:context=".MainActivity" />
14     <Button 
15         android:id="@+id/start"
16         android:layout_width="fill_parent"
17         android:layout_height="wrap_content"
18         android:text="@string/start"
19         />
20     <Button 
21         android:id="@+id/end"
22         android:layout_width="fill_parent"
23         android:layout_height="wrap_content"
24         android:text="@string/end"
25         />
26 
27 </LinearLayout>

Handler使用例2
這個例子比剛纔那個例子稍微複雜些。由於這個例子中用到了handler的消息隊列機制，即經過handler中一個線程向消息隊列中用sendMessage方法發送消息，發送的消息固然能夠用來傳遞參數。在handler中用handleMessage來處理消息，處理方法是得到消息隊列中的消息參數，用這些參數來完成另一些功能。
本實驗實現的是當開始按鈕按下時，會啓動一個線程，並綁定到handler中，該線程發送帶有參數的message到handler的消息隊列中，消息隊列的另外一端獲取該消息，而且用該消息的參數來更新進度條。

軟件打開後：

 

單擊Start按鈕後，更新的進度條結果以下（怎麼感受4.1版本android進度條那麼小呢？不懂該怎麼設置）：

實驗主要部分代碼和註釋：
MainActivity.java:

 1 package com.example.handler2;
 2 import android.app.Activity;
 3 import android.os.Bundle;
 4 import android.os.Handler;
 5 import android.os.Message;
 6 import android.view.Menu;
 7 import android.view.View;
 8 import android.view.View.OnClickListener;
 9 import android.widget.Button;
10 import android.widget.ProgressBar;
11 
12 public class MainActivity extends Activity {
13 
14     private ProgressBar progress_bar = null;
15     private Button start = null;
16 
17     @Override
18     public void onCreate(Bundle savedInstanceState) {
19         super.onCreate(savedInstanceState);
20         setContentView(R.layout.activity_main);
21         progress_bar = (ProgressBar)findViewById(R.id.progress_bar);
22         start = (Button)findViewById(R.id.start);
23 
24         start.setOnClickListener(new StartOnClickListenr());
25     }
26 
27     private class StartOnClickListenr implements OnClickListener
28     {
29         public void onClick(View v) {
30             // TODO Auto-generated method stub
31             //讓進度條顯示出來
32             progress_bar.setVisibility(View.VISIBLE);
33             //將線程加入到handler的線程隊列中
34             update_progress_bar.post(update_thread);
35 
36         }
37     }
38 
39     //建立一個handler，內部完成處理消息方法
40     Handler update_progress_bar = new Handler()
41     {
42         @Override
43         public void handleMessage(Message msg) {
44             // TODO Auto-generated method stub
45             //super.handleMessage(msg);
46             //顯示進度條
47             progress_bar.setProgress(msg.arg1);
48             //從新把進程加入到進程隊列中
49             update_progress_bar.post(update_thread);
50         }       
51     };//不加這個分號則不能自動添加代碼
52 
53     Runnable update_thread = new Runnable()
54     {
55         int i = 0;
56         public void run() {
57             // TODO Auto-generated method stub
58             i += 10;
59             //首先得到一個消息結構
60             Message msg = update_progress_bar.obtainMessage();
61             //給消息結構的arg1參數賦值
62             msg.arg1 = i;
63             //延時1s，java中的try+catch用來排錯處理
64             try {
65                 Thread.sleep(1000);
66             } catch (InterruptedException e) {
67                 // TODO: handle exception
68                 e.printStackTrace();
69             }
70             //把消息發送到消息隊列中
71             update_progress_bar.sendMessage(msg);
72             if(i == 100)
73                 //把線程從線程隊列中移除
74                 update_progress_bar.removeCallbacks(update_thread);
75         }       
76     };
77 
78     @Override
79     public boolean onCreateOptionsMenu(Menu menu) {
80         getMenuInflater().inflate(R.menu.activity_main, menu);
81         return true;
82     }
83 }

activity_main.xml:

 1 <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
 2     xmlns:tools="http://schemas.android.com/tools"
 3     android:layout_width="match_parent"
 4     android:layout_height="match_parent" >
 5     <Button 
 6         android:id="@+id/start"
 7         android:layout_width="fill_parent"
 8         android:layout_height="wrap_content"
 9         android:layout_alignParentBottom="true"
10         android:text="@string/start"
11         />
12     <ProgressBar 
13         android:id="@+id/progress_bar"
14         android:layout_width="fill_parent"
15         android:layout_height="100dip"
16         android:layout_alignParentTop="true"
17         style="?android:attr/progressBarStyleHorizontal"
18         android:visibility="gone"
19         />
20 
21 </RelativeLayout>

Handler使用例3
上面2個例子表面上看handler使用了post方法啓動了runnbale，其實啓動的線程和activity主線程是同一個線程，由於它只是運行了線程的run方法，而不是start方法。Mars老師實驗3的目的是爲了驗證僅使用handler的post方法是否處於同一個線程。
該實驗在主activtiy的onCreate函數中打印了2條關於本線程的信息，而後建立一個handler併爲它綁定一個線程，在線程的run方法中也打印了線程的信息，觀察2者的信息是否同樣。

結果以下：
說明這2個線程確實是同一線程，而且能夠看出主界面中的文字大概過了10s才顯示出來，由於語句setContentView(R.layout.activity_main);放在了handler的post啓動語句後面，而handler綁定的線程中又延時了10s，因此同時也證實了只有是同一個線程纔會出現這種狀況。

程序主要代碼和註釋以下：

 

MainActivity.java:

 1 package com.example.handler3;
 2 import android.app.Activity;
 3 import android.os.Bundle;
 4 import android.os.Handler;
 5 import android.view.Menu;
 6 
 7 public class MainActivity extends Activity {
 8 
 9     //新建一個handler
10     private Handler handler = new Handler();
11     @Override
12     public void onCreate(Bundle savedInstanceState) {
13         super.onCreate(savedInstanceState);
14 
15         //將runnable加載到handler的線程隊列中去
16       //  handler.post(r);        
17         Thread t = new Thread(r);
18         t.start();
19         setContentView(R.layout.activity_main);
20         //打印activtiy線程信息
21         System.out.println("activity_id---->"+Thread.currentThread().getId());
22         System.out.println("activity_name---->"+Thread.currentThread().getName());
23     }
24 
25     Runnable r = new Runnable()
26     {
27         public void run() {
28             // TODO Auto-generated method stub
29             //打印新建線程信息
30             System.out.println("handler_id---->"+Thread.currentThread().getId());
31             System.out.println("handler_name---->"+Thread.currentThread().getName());
32             //延時10s，爲了觀察主界面中內容出現的時間
33             try {
34                 Thread.sleep(10000);
35             } catch (InterruptedException e) {
36                 // TODO: handle exception
37                 e.printStackTrace();
38             }
39         }
40 
41     };
42 
43     @Override
44     public boolean onCreateOptionsMenu(Menu menu) {
45         getMenuInflater().inflate(R.menu.activity_main, menu);
46         return true;
47     }
48 }

若是把語句：
handler.post(r);
換成：
Thread t = new Thread(r);
t.start();
其它的不變，則程序運行時主界面內容馬上就顯示出來了，且系統輸出以下：
這2者都說明這樣綁定的線程與它所在的activity線程就不是同一個線程了。

Handler使用例4
這個例子將學會怎樣不使用runnable來啓動一個線程，而是用HandlerThread的looper來構造一個handler，而後該handler本身得到消息，並傳遞數據，而後又本身處理消息，固然這是在另外一個線程中完成的。
消息結構中傳遞簡單的整型能夠採用它的參數arg1和arg2，或者傳遞一些小的其它數據，能夠用它的object，該object能夠是任意的對象。當須要傳送比較大的數據是，能夠使用消息的setData方法，該方法須要傳遞一個Bundle的參數。Bundle中存放的是鍵值對的map，只是它的鍵值類型和數據類型比較固定而已。

程序主要代碼和註釋以下：
MainActivity.java:

 1 package com.example.handler4;
 2  
 3 
 4 import android.app.Activity;
 5 import android.os.Bundle;
 6 import android.os.Handler;
 7 import android.os.HandlerThread;
 8 import android.os.Looper;
 9 import android.os.Message;
10 import android.view.Menu;
11 
12 public class MainActivity extends Activity {
13 
14     @Override
15     public void onCreate(Bundle savedInstanceState) {
16         super.onCreate(savedInstanceState);
17         setContentView(R.layout.activity_main);
18 
19         System.out.println("activity_ID---->"+Thread.currentThread().getId());
20         //新建一個HanderThread對象，該對象實現了用Looper來處理消息隊列的功能
21         HandlerThread handler_thread = new HandlerThread("handler_thread");
22         handler_thread.start();
23         //MyHandler類是本身繼承的一個類，這裏採用hand_thread的Looper來初始化它
24         MyHandler my_handler = new MyHandler(handler_thread.getLooper());
25         //得到一個消息msg
26         Message msg = my_handler.obtainMessage();
27 
28         //採用Bundle保存數據，Bundle中存放的是鍵值對的map，只是它的鍵值類型和數據類型比較固定而已
29         Bundle b = new Bundle();
30         b.putString("whether", "晴天");
31         b.putInt("temperature", 34);
32         msg.setData(b);
33       //將msg發送到本身的handler中，這裏指的是my_handler,調用該handler的HandleMessage方法來處理該mug
34         msg.sendToTarget();
35     }
36 
37     class MyHandler extends Handler
38     {
39         //空的構造函數
40         public MyHandler()
41         {}
42         //以Looper類型參數傳遞的函數，Looper爲消息泵，不斷循環的從消息隊列中獲得消息並處理，所以
43         //每一個消息隊列都有一個Looper，由於Looper是已經封裝好了的消息隊列和消息循環的類
44         public MyHandler(Looper looper)
45         {
46             //調用父類的構造函數
47             super(looper);
48         }
49         @Override
50         public void handleMessage(Message msg) {
51             // TODO Auto-generated method stub
52             System.out.println("Handler_ID---->"+Thread.currentThread().getId());
53             System.out.println("Handler_Name---->"+Thread.currentThread().getId());
54             //將消息中的bundle數據取出來
55             Bundle b = msg.getData();
56             String whether = b.getString("whether");
57             int temperature = b.getInt("temperature");
58             System.out.println("whether= "+whether+" ,temperature= "+temperature);
59         }
60 
61     }
62 
63     @Override
64     public boolean onCreateOptionsMenu(Menu menu) {
65         getMenuInflater().inflate(R.menu.activity_main, menu);
66         return true;
67     }
68 }

總結：
Android中的handler能夠用來完成異步的消息出來，即發送消息和接收消息相互獨立，能夠同時運行。在例1和例2中，實際上handler中使用的線程是與它所在的activity處於同一個主線程，由於handler中調用的runnable接口是直接運行該接口的run函數的，而不是start函數。例3專門比較了這2中狀況。例4學會使用怎樣在新線程中處理消息的方法。

 

開發環境爲android4.1