Handler初探

    Android中有着和J2SE同樣優秀的多線程支持，可以把那些耗時較多的操作放在新線程中操作。但是當新線程中有涉及到操作UI的操作時，就會對主線程產生危險，因此，Android提供了Handler作爲主線程和子線程的紐帶。同時，Handler對象初始化後，就默認與對它初始化的進程的消息隊列綁定，因此可以利用Handler所包含的消息隊列，制定一些操作的順序。

   根據SDK文檔的說明：“A Handler allows you to send and process Message and Runnable objects associated with a thread's MessageQueue.”由此可以清楚的知道，可以把消息和Runnble對象發送到與Handler對象所關聯的消息隊列中去。

    

     下面，就Handler的以上兩點作用，分別進行討論。

    1. 傳遞Message。用於接受子線程發送的數據, 並用此數據配合主線程更新UI。

    在Android中，對於UI的操作通常需要放在主線程中進行操作。如果在子線程中有關於UI的操作，那麼就需要把數據消息作爲一個Message對象發送到消息隊列中，然後，有Handler中的handlerMessge方法處理傳過來的數據信息，並操作UI。當然，Handler對象是在主線程中初始化的，以爲它需要綁定在主線程的消息隊列中。

    類sendMessage(Message msg)方法實現發送消息的操作。 在初始化Handler對象時重寫的handleMessage方法來接收Messgae並進行相關操作。

  

 
 

//Handler處理子線程消息代碼示例：

public class Activity01 extends Activity
{
    //聲明ProgressBar對象
    private ProgressBar m_ProgressBar;
    private ProgressBar m_ProgressBar2;
    private Button mButton01;
    protected static final int GUI_STOP_NOTIFIER = 0x108;
    protected static final int GUI_THREADING_NOTIFIER = 0x109;
    public int intCounter=0;
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        //設置窗口模式，，因爲需要顯示進度條在標題欄
        requestWindowFeature(Window.FEATURE_PROGRESS);
        setProgressBarVisibility(true);
        setContentView(R.layout.main);

        //取得ProgressBar
        m_ProgressBar = (ProgressBar) findViewById(R.id.ProgressBar01);
        m_ProgressBar2= (ProgressBar) findViewById(R.id.ProgressBar02);
        mButton01 = (Button)findViewById(R.id.Button01);

        m_ProgressBar.setIndeterminate(false);
        m_ProgressBar2.setIndeterminate(false);

        //當按鈕按下時開始執行,
        mButton01.setOnClickListener(new Button.OnClickListener()
        {
          @Override
          public void onClick(View v)
          {
            // TODO Auto-generated method stub

              //設置ProgressBar爲可見狀態
              m_ProgressBar.setVisibility(View.VISIBLE);
              m_ProgressBar2.setVisibility(View.VISIBLE);
              //設置ProgressBar的最大值
              m_ProgressBar.setMax(100);
              //設置ProgressBar當前值
              m_ProgressBar.setProgress(0);
              m_ProgressBar2.setProgress(0);

              //通過線程來改變ProgressBar的值
  new Thread(new Runnable() {
     public void run()
        {
     for (int i = 0; i < 10; i++)
        {
           try
           {
                 intCounter = (i + 1) * 20;
                 Thread.sleep(1000);

            if (i == 4)
            {
            Message m = new Message();

             m.what = Activity01.GUI_STOP_NOTIFIER;
            Activity01.this.myMessageHandler.sendMessage(m);
   //將message發送到消息隊列
              break;
             }
            else
           {
           Message m = new Message();
           m.what = Activity01.GUI_THREADING_NOTIFIER;
           Activity01.this.myMessageHandler.sendMessage(m);
  //將message發送到消息隊列
                                }
                            }
                            catch (Exception e)
                            {
                                e.printStackTrace();
                            }
                        }
                    }
                }).start();
            }
        });
    }

//通過匿名類複寫Handler類中的handleMessage方法，用於接收傳遞到消息隊列中的Message，並進行UI操作。
      Handler myMessageHandler = new Handler()
      {
        // @Override
          public void handleMessage(Message msg)
          {
              switch (msg.what)
              {
              //ProgressBar已經是對大值
              case Activity01.GUI_STOP_NOTIFIER:
                  m_ProgressBar.setVisibility(View.GONE);
                  m_ProgressBar2.setVisibility(View.GONE);
                  Thread.currentThread().interrupt();
                  break;
              case Activity01.GUI_THREADING_NOTIFIER:
                  if (!Thread.currentThread().isInterrupted())
                  {
                      // 改變ProgressBar的當前值
                      m_ProgressBar.setProgress(intCounter);
                      m_ProgressBar2.setProgress(intCounter);

                      // 設置標題欄中前景的一個進度條進度值
                      setProgress(intCounter*100);
                      // 設置標題欄中後面的一個進度條進度值
                      setSecondaryProgress(intCounter*100);//
                  }
                  break;
              }
              super.handleMessage(msg);
         }
      };
}

    以上的例子中，子線程只是對進度條的參數進行了變更，並將結果以message形式發送到消息隊列中去，子線程的內部並未進行UI操作，而是在重寫的Handler的handlerMessage方法中操作了UI界面。

    2. 傳遞Runnable對象。用於通過Handler綁定的消息隊列，安排不同操作的執行順序。

    Handler對象在進行初始化的時候，會默認的自動綁定消息隊列。利用類post方法，可以將Runnable對象發送到消息隊列中，按照隊列的機制按順序執行不同的Runnable對象中的run方法。

   

 

public class HandlerActivity extends Activity {
    /** Called when the activity is first created. */
    //聲明兩個按鈕控件
    private Button startButton = null;
    private Button endButton = null;
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        //根據控件的ID得到代表控件的對象，並未這兩個按鈕設置相應的監聽器
        startButton = (Button)findViewById(R.id.startButton);
        startButton.setOnClickListener(new StartButtonListener());
        endButton = (Button)findViewById(R.id.endButton);
        endButton.setOnClickListener(new EndButtonListener());

    }
    class StartButtonListener implements OnClickListener{

        @Override
        public void onClick(View v) {
            //調用Handler的post方法，將要執行的線程對象添加到隊列當中
            handler.post(updateThread);
        }

    }

    class EndButtonListener implements OnClickListener{

        @Override
        public void onClick(View v) {
            handler.removeCallbacks(updateThread);
        }

    }
    //創建一個Handler對象
    Handler handler  = new Handler();
    //將要執行的操作寫在線程對象的run方法當中
    Runnable updateThread =  new Runnable(){

        @Override
        public void run() {
            System.out.println("UpdateThread");
            //在run方法內部，執行postDelayed或者是post方法
            handler.postDelayed(updateThread, 3000);
        }

    };
}

    程序的運行結果就是每隔3秒鐘，就會在控制檯打印一行UpdateTread。這是因爲實現了Runnable接口的updateThread對象進入了空的消息隊列即被立即執行run方法，而在run方法的內部，又在3000ms之後將其再次發送進入消息隊列中。

   3. Handler和多線程

    post方法雖然發送的是一個實現了Runnable接口的類對象，但是它並非創建了一個新線程，而是執行了該對象中的run方法。也就是說，整個run中的操作和主線程處於同一個線程。

    這樣對於那些簡單的操作，似乎並不會影響。但是對於耗時較長的操作，當它被加入到消息隊列中之後執行會佔用很長的時間，以至於處於同一線程的其他操作無法繼續執行，就會出現“假死”。爲了解決這個問題，就需要使得handler綁定到一個新開啓線程的消息隊列上，在這個處於另外線程的上的消息隊列中處理傳過來的Runnable對象和消息。SDK文檔中也提供了相關說明：

     When a process is created for your application, its main thread is dedicated to running a message queue that takes care of managing the top-level application objects (activities, broadcast receivers, etc) and any windows they create. You can create your own threads, and communicate back with the main application thread through a Handler. This is done by calling the same post or sendMessage methods as before, but from your new thread. The given Runnable or Message will than be scheduled in the Handler's message queue and processed when appropriate.

     具體操作方法如下：

 
 

public class HandlerTest2 extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    //打印了當前線程的ID
    System.out.println("Activity-->" + Thread.currentThread().getId());
    //生成一個HandlerThread對象
    HandlerThread handlerThread = new HandlerThread("handler_thread");
    //在使用HandlerThread的getLooper()方法之前，必須先調用該類的start()，同時開啓一個新線程;
    handlerThread.start();
    //將由HandlerThread獲取的Looper傳遞給Handler對象，即由處於另外線程的Looper代替handler初始化時默認綁定的消息隊列來處理消息。
    MyHandler myHandler = new MyHandler(handlerThread.getLooper());
    Message msg = myHandler.obtainMessage();
    //將msg發送到目標對象，所謂的目標對象，就是生成該msg對象的handler對象
    Bundle b = new Bundle();
    b.putInt("age", 20);
    b.putString("name", "Jhon");
    msg.setData(b);
    msg.sendToTarget();  //將msg發送到myHandler
    }

    //定義類
    class MyHandler extends Handler{
    public MyHandler(){

    }

    public MyHandler(Looper looper){
        super(looper);
    }
    @Override
    public void handleMessage(Message msg) {
        Bundle b = msg.getData();
        int age = b.getInt("age");
        String name = b.getString("name");
        System.out.println("age is " + age + ", name is" + name);
        System.out.println("Handler--->" + Thread.currentThread().getId());
        System.out.println("handlerMessage");
        }
    }
}

    這樣，當使用sendMessage方法傳遞消息或者使用post方法傳遞Runnable對象時，就會把它們傳遞到與handler對象綁定的處於另外一個線程的消息隊列中，它們將在另外的消息隊列中被處理。而主線程還會在發送操作完成時候繼續進行，不會影響當前的操作。

    這裏需要注意，這裏用到的多線程並非由Runnable對象開啓的，而是ThreadHandler對象開啓的。Runnable對象只是作爲一個封裝了操作的對象被傳遞，並未產生新線程。