Android教程網
  1. 首頁
  2. Android 技術
  3. Android 手機
  4. Android 系統教程
  5. Android 游戲
 Android教程網 >> Android技術 >> 關於Android編程 >> Android中對Handle機制的理解

Android中對Handle機制的理解

編輯:關於Android編程

一、重要參考資料
【參考資料】
目前來看,下面的幾個網址中的內容質量比較不錯,基本不需要再讀別的網址了。
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=%7B@link]{@link[/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)對象.
  1. 上一頁:
  2. 下一頁:
熱門文章
閱讀排行版
Copyright © Android教程網 All Rights Reserved