Android學習筆記(5)——淺談Handler

這次淺談一下Handler,為什麼會出現Handler這個功能特性呢？首先，在之前的基本控制項，基本都是在Activity的onCreate(Bundle savedInstanceState)方法中調用和處理的，但是，在有些情況，比如在網路上下載軟體等一些需要等待回應時間比較長的操作，如果同樣放在Activity的該方法中的話，那麼在執行該方法的時候，整個Activity是不可動的，使用者只能乾等著，這樣的使用者體驗是十分差的，這種處理方式帶來的最好結果是等待了一段時間後，得到了想要的結果，不好的情況就是等了N久，也沒有出現結果，有的甚至會使Activity報錯，為了避免這些情況的發生，所以引入了Handler的特性，他就像是一個線程隊列，它也是一種非同步訊息處理。
首先我們先看一個例子，通過例子來對Handler進行認識。
布局檔案中是兩個按鈕，分別是start和stop，分別控制線程的開始和停止。
<Button 
    android:id="@+id/start"
    android:layout_height="wrap_content"
    android:layout_width="fill_parent"
    android:text="@string/start"
/>
<Button 
    android:id="@+id/stop"
    android:layout_height="wrap_content"
    android:layout_width="fill_parent"
    android:text="@string/stop"
/>
在Activity中的代碼如下：
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
 
public class HandlerDemo1Activity extends Activity {
    Button startButton = null;
    Button endButton = null;
    Handler handler = new Handler();
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        startButton = (Button)findViewById(R.id.start);
        startButton.setOnClickListener(new StartListener());
        endButton = (Button)findViewById(R.id.end);
        endButton.setOnClickListener(new EndListener());
    }
    
    class StartListener implements OnClickListener{
 
        @Override
        public void onClick(View arg0) {
            // TODO Auto-generated method stub
            handler.post(HandlerThread);
        }
        
    }
    
    class EndListener implements OnClickListener{
        @Override
        public void onClick(View arg0) {
            // TODO Auto-generated method stub
            handler.removeCallbacks(HandlerThread);
        }
        
    }
    
    Runnable HandlerThread = new Runnable() {
        
        @Override
        public void run() {
            // TODO Auto-generated method stub
            System.out.println("HandlerThread is Running......");
            handler.postDelayed(HandlerThread, 3000);
        }
    };
}
我們可以看到，在Activity中對兩個按鈕分別綁定了事件監聽器，還建立了Handler的一個執行個體，以及建立了一個匿名內部類，是一個實現Runnable介面的線程HandlerThread。
當start按鈕按下時，即會執行handler.post(HandlerThread);這一句代碼，之前說過，Handler用一個線程隊列，這句代碼即是把HandlerThread這個線程加入了handler的線程隊列中，因為加入的這個HandlerThread是第一個線程，因此它會馬上執行它的run()方法。在run()方法中，handler.postDelayed(HandlerThread, 3000);又再一次將HandlerThread放入handler的線程隊列中，這裡設定了3000ms的延遲。這樣，整個程式會不斷地運行，且每隔3000ms在LogCat中列印出"HandlerThread is Running......"。
 
但是，值得注意的是，不要以為現在handler的出現，使得這些列印操作所在的線程和主線程分開了，其實不然，這雷根本沒有兩個線程在跑，這些列印出來的內容，也是主線程跑出來的。我們可以做個實驗，在onCreate函數之後以及列印語句的地方把當前的Thread的名字通過Thread.currentThread.getName()列印出來，可以看到，都是相同的，都是main，這就意味著都是主線程跑出來的。我們知道一個線程的啟動需要start()方法，而在這個程式中並沒有對HandlerThread進行start，而是直接調用了run()方法了。所以只是main線程在跑就不足為奇了。
從上面的例子來看，這個Handler如果這樣用的話，並不是我們想要的效果，因為它沒有實現非同步，還是在一個主線程中運行。
因此，我們必須換一種方式來使用Handler。
要實現Handler的非同步多線程，就需要瞭解另兩個類，一個是Message類，另一個是Looper類。
每個Handler對象中都有一個訊息佇列，隊列中就是存放的Message對象，可以使用obtainMessage()來獲得訊息對象。同時，Message對象是用來傳遞使用的，它能傳遞兩個整型和一個Object，盡量使用Message的arg1與arg2兩個整型來傳遞參數，那樣系統消耗最小（API如是說）,如果傳遞資料量比較大，則可以使用setData(Bundle a)的方法，其中的Bundle對象可以粗略的看成是一個Map對象，但它的Key都是String，而value是有限的一些類型，可以再API裡查看。
Looper類有能夠迴圈地從訊息佇列中取得訊息的功能，我們可以在一個線程中使用Looper，這樣，該線程就可以迴圈的在訊息佇列裡取得訊息，知道訊息佇列為空白為止。但我們一般不直接建立和使用Looper，在Android提供的HandlerThread類中，就實現了Looper的功能，所以我們只要使用HandlerThread這個類就可以了，我們用HandlerThread的對象調用getLooper()來得到該線程的Looper對象。
我們來看下面這個例子
 
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
 
public class HandlerDemo2Activity extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        System.out.println("Activity---->"+Thread.currentThread().getName());
        HandlerThread handlerThread = new HandlerThread("HandlerThread");//建立一個HandlerThread對象，它是一個線程
        handlerThread.start();//啟動線程
        
        MyHandler myHandler = new MyHandler(handlerThread.getLooper());//建立一個MyHandler對象，該對象繼承了Handler，從下面的MyHandler類中可以看到，調用的是Handler父類的Handler(Looper looper)的建構函式，而這裡傳進去的Looper對象是從HandlerThread中取得的。
        Message msg = myHandler.obtainMessage();//獲得訊息對象
        msg.sendToTarget();//把得到的訊息對象發送給產生該訊息的Handler，即myHandler，當myHandler接收到訊息後，就會調用其handleMessage的方法來處理訊息
    }
    
    class MyHandler extends Handler{
        public MyHandler() {//建構函式
            // TODO Auto-generated constructor stub
        }
        
        public MyHandler(Looper looper){//建構函式
            super(looper);//實現了父類的該建構函式
        }
        
        @Override
        public void handleMessage(Message msg) {//當這個Handler接收到Message對象的時候，會自動調用這個方法，來對Message對象進行處理
            // TODO Auto-generated method stub
            System.out.println("Handler---->"+Thread.currentThread().getName());
        }
    }
}
上面的代碼在LogCat中System.out的執行結果為：
Acitivity---->main
Handler---->HandlerThread
這就說明了，使用Handler，結合Looper和Message，可以實現與主線程的分離，從而可以實現多線程和非同步處理。
以上只是個人淺談Handler，附件是兩個例子的代碼，僅供參考。
本文出自 “戰神殿” 部落格