Android中對Handle機制的理解

Android中對Handle機制的理解
一、重要參考資料
【參考資料】
目前來看，下面的幾個網址中的內容品質比較不錯，基本不需要再讀別的網址了。
1、android訊息機制
Android訊息機制(一)
一、 角色描述
1.Looper: 一個線程可以產生一個Looper對象，由它來管理此線程裡的Message Queue(訊息佇列)。
2.Handler: 你可以構造Handler對象來與Looper溝通，以便push新訊息到Message Queue裡；或者接收Looper(從Message Queue取出)所送來的訊息。
3. Message Queue(訊息佇列):用來存放線程放入的訊息。
4．線程：UI thread 通常就是main thread，而Android啟動程式時會替它建立一個Message Queue。
每一個線程裡可含有一個Looper對象以及一個MessageQueue資料結構。在你的應用程式裡，可以定義Handler的子類別來接收Looper所送出的訊息。

在你的Android程式裡，新誕生一個線程，或執行 (Thread)時，並不會自動建立其Message Loop。
Android裡並沒有Global的Message Queue資料結構，例如，不同APK裡的對象不能透過Massage Queue來交換訊息(Message)。 例如：線程A的Handler對象可以傳遞訊息給別的線程，讓別的線程B或C等能送訊息來給線程A(存於A的Message Queue裡(//如何理解？))。
線程A的Message Queue裡的訊息，只有線程A所屬的對象可以處理。
使用Looper.myLooper可以取得當前線程的Looper對象。
使用mHandler = new EevntHandler(Looper.myLooper());可用來構造當前線程的Handler對象；其中，EevntHandler是自已實現的Handler的子類別。
使用mHandler = new EevntHandler(Looper.getMainLooper()); 可誕生用來處理main線程的Handler對象；其中，EevntHandler是自已實現的Handler的子類別。


這樣描述可能太抽像，下面舉幾個實際的例子來說明：
二、 舉例
1.同線程內不同組件間的訊息傳遞
Looper類用來管理特定線程內對象之間的訊息交換(Message Exchange)。你的應用程式可以產生許多個線程。而一個線程可以有許多個組件，這些組件之間常常需要互相交換訊息。如果有這種需要，您可以替線程構造一個Looper對象，來擔任訊息交換的管理工作。Looper對象會建立一個MessageQueue資料結構來存放各對象傳來的訊息(包括UI事件或System事件等)。如：

每一個線程裡可含有一個Looper對象以及一個MessageQueue資料結構。在你的應用程式裡，可以定義Handler的子類別來接收Looper所送出的訊息。

同線程不同組件之間的訊息傳遞：

public class Activity1 extends Activity implements OnClickListener{        Button button = null;        TextView text = null;        @Override        protected void onCreate(Bundle savedInstanceState) {               super.onCreate(savedInstanceState);               setContentView(R.layout.activity1);                       button = (Button)findViewById(R.id.btn);               button.setOnClickListener(this);               text = (TextView)findViewById(R.id.content);        }        public void onClick(View v) {               switch (v.getId()) {               case R.id.btn: //組件1                     Looper looper = Looper.myLooper();//取得當前線程裡的looper                      MyHandler mHandler = new MyHandler(looper);//構造一個handler使之可與looper通訊                     //buton等組件可以由mHandler將訊息傳給looper後,再放入messageQueue中,同時mHandler也可以接受來自looper訊息                     mHandler.removeMessages(0);                      String msgStr = "主線程不同組件通訊:訊息來自button";                      Message m = mHandler.obtainMessage(1, 1, 1, msgStr);//構造要傳遞的訊息                     mHandler.sendMessage(m);//發送訊息:系統會自動調用handleMessage方法來處理訊息                      break;               }                    }             private class MyHandler extends Handler{                            public MyHandler(Looper looper){                      super(looper);               }               @Override               public void handleMessage(Message msg) {//處理訊息                      text.setText(msg.obj.toString()); //組件2              }                    } } 

說明：
此程式啟動時，當前線程(即主線程, main thread)已誕生了一個Looper對象，並且有了一個MessageQueue資料結構。
looper = Looper.myLooper ();

調用Looper類別的靜態myLooper()函數，以取得目前線程裡的Looper對象.

mHandler = new MyHandler (looper);

構造一個MyHandler對象來與Looper溝通。Activity等對象可以藉由MyHandler對象來將訊息傳給Looper，然後放入MessageQueue裡；MyHandler對象也扮演Listener的角色，可接收Looper對象所送來的訊息。
Message m = mHandler.obtainMessage(1, 1, 1, obj);

先構造一個Message對象，並將資料存入對象裡。
mHandler.sendMessage(m);

就透過mHandler對象而將訊息m傳給Looper，然後放入MessageQueue裡。
此時，Looper對象看到MessageQueue裡有訊息m，就將它廣播出去，mHandler對象接到此訊息時，會呼叫其handleMessage()函數來處理，於是輸出"This my message!"於畫面上，


2、Android訊息機制二

Android訊息處理機制(二)

角色綜述（回顧）:

(1)UI thread 通常就是main thread，而Android啟動程式時會替它建立一個MessageQueue。

(2)當然需要一個Looper對象，來管理該MessageQueue。

(3)我們可以構造Handler對象來push新訊息到Message Queue裡；或者接收Looper(從Message Queue取出)所送來的訊息。

(4)線程A的Handler對象可以傳遞給別的線程，讓別的線程B或C等能送訊息來給線程A(存於A的Message Queue裡)。

(5)線程A的Message Queue裡的訊息，只有線程A所屬的對象可以處理。

子線程傳遞訊息給主線程publicclass Activity2extends Activityimplements OnClickListener{       Button button =null;       TextView text =null;       MyHandler mHandler = null;       Thread thread ;       @Override       protectedvoid onCreate(Bundle savedInstanceState) {              super.onCreate(savedInstanceState);              setContentView(R.layout.activity1);                      button = (Button)findViewById(R.id.btn);              button.setOnClickListener(this);              text = (TextView)findViewById(R.id.content);       }       publicvoid onClick(View v) {              switch (v.getId()) {              case R.id.btn:                     thread =new MyThread();                     thread.start();                     break;              }                   }            privateclass MyHandlerextends Handler{                           public MyHandler(Looper looper){                     super(looper);              }              @Override              publicvoid handleMessage(Message msg) {//處理訊息                     text.setText(msg.obj.toString());              }                   }       privateclass MyThreadextends Thread{              @Override              publicvoid run() {                     Looper curLooper = Looper.myLooper();                     Looper mainLooper = Looper.getMainLooper();                     String msg ;                     if(curLooper==null){                            mHandler =new MyHandler(mainLooper);                            msg = "curLooper is null";                     }else{                            mHandler =new MyHandler(curLooper);                            msg = "This is curLooper";                     }                     mHandler.removeMessages(0);                     Message m = mHandler.obtainMessage(1, 1, 1, msg);                     mHandler.sendMessage(m);              }                   }}

說明：

Android會自動替主線程建立Message Queue。在這個子線程裡並沒有建立Message Queue。所以，myLooper值為null，而mainLooper則指向主線程裡的Looper。於是，執行到：

mHandler = new MyHandler (mainLooper);

此mHandler屬於主線程。

mHandler.sendMessage(m);

就將m訊息存入到主線程的Message Queue裡。mainLooper看到Message Queue裡有訊息，就會作出處理，於是由主線程執行到mHandler的handleMessage()來處理訊息。

3、Android線程間通訊的message機制
http://www.javafun.cn/viewthread.php?tid=15174、

在Android下面也有多線程的概念，在C/C++中，子線程可以是一個函數，一般都是一個帶有迴圈的函數，來處理某些資料，優先線程只是一個複雜的運算過程，所以可能不需要while迴圈，運算完成，函數結束，線程就銷毀。對於那些需要控制的線程，一般我們都是和互斥鎖相互關聯，從而來控制線程的進度，一般我們建立子線程，一種線程是很常見的，那就是帶有訊息迴圈的線程。
訊息迴圈是一個很有用的線程方式，曾經自己用C在Linux下面實現一個訊息迴圈的機制，往訊息佇列裡添加資料，然後非同步等待訊息的返回。當訊息佇列為空白的時候就會掛起線程，等待新的訊息的加入。這是一個很通用的機制。
在Android，這裡的線程分為有訊息迴圈的線程和沒有訊息迴圈的線程，有訊息迴圈的線程一般都會有一個Looper，這個事android的新概念。我們的主線程（UI線程）就是一個訊息迴圈的線程。針對這種訊息迴圈的機制，我們引入一個新的機制Handle，我們有訊息迴圈，就要往訊息迴圈裡面發送相應的訊息，自訂訊息一般都會有自己對應的處理，訊息的發送和清除，訊息的的處理，把這些都封裝在Handle裡面，注意Handle只是針對那些有Looper的線程，不管是UI線程還是子線程，只要你有Looper，我就可以往你的訊息佇列裡面添加東西，並做相應的處理。
但是這裡還有一點，就是只要是關於UI相關的東西，就不能放在子線程中，因為子線程是不能操作UI的，只能進行資料、系統等其他非UI的操作。
那麼什麼情況下面我們的子線程才能看做是一個有Looper的線程呢？我們如何得到它Looper的控制代碼呢？
Looper.myLooper();獲得當前的Looper
Looper.getMainLooper () 獲得UI線程的Lopper
我們看看Handle的初始化函數，如果沒有參數，那麼他就預設使用的是當前的Looper，如果有Looper參數，就是用對應的線程的Looper。
如果一個線程中調用Looper.prepare()，那麼系統就會自動的為該線程建立一個訊息佇列，然後調用 Looper.loop();之後就進入了訊息迴圈，這個之後就可以發訊息、取訊息、和處理訊息。這個如何發送訊息和如何處理訊息可以再其他的線程中通過Handle來做，但前提是我們的Hanle知道這個子線程的Looper，但是你如果不是在子線程運行 Looper.myLooper()，一般是得不到子線程的looper的。

public void run() {            synchronized (mLock) {                Looper.prepare();               //do something            }            Looper.loop();        }

所以很多人都是這樣做的：我直接在子線程中建立handle，然後在子線程中發送訊息，這樣的話就失去了我們多線程的意義了。

class myThread extends Thread{             private EHandler mHandler ;             public void run() {                 Looper myLooper, mainLooper;                 myLooper = Looper.myLooper ();                mainLooper = Looper.getMainLooper ();                String obj;                if (myLooper == null ){                         mHandler = new EHandler(mainLooper);                         obj = "current thread has no looper!" ;                }                else {                     mHandler = new EHandler(myLooper);                     obj = "This is from current thread." ;                }                mHandler .removeMessages(0);                Message m = mHandler .obtainMessage(1, 1, 1, obj);                mHandler .sendMessage(m);             }  }

可以讓其他的線程來控制我們的handle，可以把 private EHandler mHandler ;放在外面，這樣我們的發訊息和處理訊息都可以在外面來定義，這樣增加程式碼的美觀，結構更加清晰。
對如任何的Handle，裡面必須要重載一個函數
public void handleMessage(Message msg)
這個函數就是我們的訊息處理，如何處理，這裡完全取決於你，然後通過 obtainMessage和 sendMessage等來產生和發送訊息，removeMessages(0)來清除訊息佇列。Google真是太智慧了，這種架構的產生，我們寫代碼更加輕鬆了。
有的時候，我們的子線程想去改變UI了，這個時候千萬不要再子線程中去修改，獲得UI線程的Looper，然後發送訊息即可。
我們看看Goole Music App的原始碼。
在MediaPlaybackActivity.java中，我們可以看一下再OnCreate中的有這樣的兩句：

mAlbumArtWorker = new Worker("album art worker");        mAlbumArtHandler = new AlbumArtHandler(mAlbumArtWorker.getLooper());

很明顯這兩句，是構建了一個子線程。並且這個子線程還是Looper的子線程，這裡很牛逼的使用了 mAlbumArtWorker.getLooper()這個函數，因為我們知道，我們能夠得到子線程的Looper的途徑只有一個：就是在子線程中調用 Looper.myLooper ()，並且這個函數還要在我們perpare之後調用才能得到正確的Looper，但是他這裡用了一個這樣的什麼東東 getLooper，不知道它是如何?的？
這裡有一個大概的思路，我們在子線程的的prepare之後調用 myLooper ()這個方法，然後儲存在一個成員變數中，這個getLooper就返回這個東西，但是這裡會碰到多線程的一個很突出的問題，同步。我們在父線程中調用 mAlbumArtWorker.getLooper()，但是想要這個返回正確的looper就必須要求我們的子線程運行了prepare，但是這個東西實在子線程啟動並執行，我們如何保證呢？
我們看Google是如何?的？

private class Worker implements Runnable {        private final Object mLock = new Object();        private Looper mLooper;                /**         * Creates a worker thread with the given name. The thread         * then runs a [[email protected]][email protected][/email] android.os.Looper}.         * @param name A name for the new thread         */        Worker(String name) {            Thread t = new Thread(null, this, name);            t.setPriority(Thread.MIN_PRIORITY);            t.start();            synchronized (mLock) {                while (mLooper == null) {                    try {                        mLock.wait();                    } catch (InterruptedException ex) {                    }                }            }        }                public Looper getLooper() {            return mLooper;        }                public void run() {            synchronized (mLock) {                Looper.prepare();                mLooper = Looper.myLooper();                mLock.notifyAll();            }            Looper.loop();        }                public void quit() {            mLooper.quit();        }    }

我們知道，一個線程類的建構函式是在主線程中完成的，所以在我們的 Worker的建構函式中我們創佳一個線程，然後讓這個線程運行，這一這個線程的建立是指定一個 Runnabl，這裡就是我們的Worker本身，在主線程調用 t.start();，這後，我們子線程已經建立，並且開始執行work的run方法。然後下面的代碼很藝術：

synchronized (mLock) {                while (mLooper == null) {                    try {                        mLock.wait();                    } catch (InterruptedException ex) {                    }                }            }

我們開始等待我們的子線程給mLooper賦值，如果不賦值我們就繼續等，然後我們的子線程在運行run方法之後，在給 mLooper賦值之後，通知worker夠著函數中的wait，然後我們的建構函式才能完成，所以我們說：
mAlbumArtWorker = new Worker("album art worker");
這句本身就是阻塞的，它建立了一個子線程，開啟了子線程，並且等待子線程給mLooper賦值，賦值完成之後，這個函數才返回，這樣才能保證我們的子線程的Looper的擷取絕對是正確的，這個構思很有創意。值得借鑒

4、Android中Handler的使用方法-在子線程中更新介面

二、知識要點

一、知識點
1、handler應該由處理訊息的線程建立。

2、handler與建立它的線程相關聯，而且也只與建立它的線程相關聯。handler運行在建立它的線程中，所以，如果在handler中進行耗時的操作，會阻塞建立它的線程。
【來源】以上來自：
二、一些知識點
1、Android的線程分為有訊息迴圈的線程和沒有訊息迴圈的線程，有訊息迴圈的線程一般都會有一個Looper。主線程（UI線程）就是一個訊息迴圈的線程。

2、
Looper.myLooper(); //獲得當前的Looper
Looper.getMainLooper () //獲得UI線程的Lopper

3、Handle的初始化函數（建構函式），如果沒有參數，那麼他就預設使用的是當前的Looper，如果有Looper參數，就是用對應的線程的Looper。

4、如果一個線程中調用Looper.prepare()，那麼系統就會自動的為該線程建立一個訊息佇列，然後調用 Looper.loop();之後就進入了訊息迴圈，這個之後就可以發訊息、取訊息、和處理訊息。【來源】以上來自：http://www.javafun.cn/viewthread.php?tid=1517

三、應用執行個體
3.1handler傳遞message【應用樣本一】
 

package com.android.tutor;  import java.util.Timer;  import java.util.TimerTask;  import android.app.Activity;  import android.os.Bundle;  import android.os.Handler;  import android.os.Message;  public class HandlerDemo extends Activity {            //title為setTitle方法提供變數,這裡為了方便我設定成了int型      private int title = 0;            private Handler mHandler = new Handler(){                   public void handleMessage(Message msg) {              switch (msg.what) {              case 1:                  updateTitle();                  break;              }          };      };      public void onCreate(Bundle savedInstanceState) {          super.onCreate(savedInstanceState);          setContentView(R.layout.main);                    Timer timer = new Timer();          timer.scheduleAtFixedRate(new MyTask(), 1, 5000);      }                private class MyTask extends TimerTask{          @Override          public void run() {                            Message message = new Message();              message.what = 1;             mHandler.sendMessage(message);                       }         }                  public void updateTitle(){                    setTitle("Welcome to Mr Wei's blog " + title);          title ++;      }  }  

上面的代碼，直接在主線程中定義Handler成員。在子線程中通過主線程的handler向主線程發送訊息。其使用步驟如下：
1、在主線程中定義handler，並為這個handler實現handleMessage方法。
2、在子線程中調用主線程的handler，通過其sendMessage方法發送訊息。

3.2handler傳遞runnable對象還有另外一種用Handler來進行線程間通訊的方式，那就是用Handler來傳遞一個runnable對象，而不是一個message。
【應用執行個體三】

使用步驟
1、在主線程中定義Handler對象
2、構造一個runnable對象，為該對象實現runnable方法，在該方法中進行一些你想做的耗時操作。
3、在子線程中使用Handler對象post(runnable)對象.