你的應用程序能夠產生很多個線程。

而一個線程能夠有很多個組件，這些組件之間經常須要互相交換訊息。假設有這樣的須要，您能夠替線程構造一個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消息機制二
http://xtfncel.javaeye.com/blog/663518

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();
        }

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);
             }
  }

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

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();
        }
    }

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

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 ++;  
    }  
}