Android Handler訊息傳遞機制詳解

投稿發表於2015-04-03
Android

1.為什麼要用Handler

出於效能優化的考慮,Android UI操作並不是執行緒安全,如果有多個執行緒併發操作UI元件,可能導致執行緒安全問題。可以設想下,如果在一個Activity中有多個執行緒去更新UI,並且都沒有加鎖機制,可能會導致什麼問題? 介面混亂,如果加鎖的話可以避免該問題但又會導致效能下降。因此,Android規定只允許UI執行緒修改Activity的UI元件。當程式第一次啟動時,Android會同時啟動一條主執行緒(Main Thread),主執行緒主要負責處理與UI相關的事件,比如使用者按鈕事件,並把相關的事件分發到對應的元件進行處理,因此主執行緒又稱為UI執行緒。那麼怎麼在新啟動的執行緒中更新UI元件呢,這就需要藉助handler的訊息傳遞機制來實現了。

2.Handler簡介

Handler類的主要作用主要有兩個:

1>在新啟動的執行緒中傳送訊息

2>在主執行緒中獲取和處理訊息

Handler類包含如下方法用於傳送、處理訊息。(這裡只列出常用的方法,如果想獲取更多方法,建議檢視api文件:http://developer.android.com/reference/android/os/Handler.html)

♦ void handlerMessage(Message msg):處理訊息的方法,該方法通常用於被重寫。

♦ final boolean hasMessage(int what):檢查訊息佇列中是否包含what屬性為指定值的訊息。

♦ sendEmptyMessage(int what):傳送空訊息

♦ final boolean sendMessage(Message msg):立即傳送訊息,注意這塊返回值,如果message成功的被放到message queue裡面則返回true,反之,返回false;(個人建議:對於這類問題不必主觀去記它,當實際使用時,直接檢視原始碼即可,原始碼中有詳細的註釋)

3.Handler、Message、Looper、MessageQueue之間的關係、工作原理

為了更好的理解Handler,先來看看和Handler相關的一些元件:

Message:Handler傳送、接收和處理的訊息物件

Looper:每個執行緒只能擁有一個Looper.它的looper()方法負責迴圈讀取MessageQueue中的訊息並將讀取到的訊息交給傳送該訊息的handler進行處理。

MessageQueue:訊息佇列,它採用先進先出的方式來管理Message。程式在建立Looper物件時,會在它的構造器中建立MessageQueue。原始碼如下:

private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}

從原始碼第2行中可以看出,在建立Looper物件時會建立一個與之關聯的MessageQueue物件。構造器是private修飾的,所以程式設計師是無法建立Looper物件的。

Handler:前面說Handler作用有兩個—傳送訊息和處理訊息,Handler傳送的訊息必須被送到指定的MessageQueue,也就是說,要想Handler正常工作必須在當前執行緒中有一個MessageQueue,否則訊息沒法儲存。而MessageQueue是由Looper負責管理的,因此要想Handler正常工作,必須在當前執行緒中有一個Looper物件,這裡分為兩種情況:

1>主執行緒(UI執行緒),系統已經初始化了一個Looper物件,因此程式直接建立Handler即可

2>程式設計師自己建立的子執行緒,這時,程式設計師必須建立一個Looper物件,並啟動它。

建立Looper使用:Looper.prepare(),檢視原始碼:

public static void prepare() {
        prepare(true);
    }

　　private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

　　private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }

通過方法呼叫,第9行建立Looper物件,建立Looper物件時同時會建立MessageQueue物件(第13行)。此外,可以看出prepare()允許一個執行緒最多有一個Looper被建立。

然後呼叫Looper的looper()方法來啟動它,looper()使用一個死迴圈不斷取出MessageQueue中的訊息,並將訊息傳送給對應的Handler進行處理。下面是Looper類中looper()方法的部分原始碼:

for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }

            // This must be in a local variable, in case a UI event sets the logger
            Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }

            msg.target.dispatchMessage(msg);

            if (logging != null) {
                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
            }

            // Make sure that during the course of dispatching the
            // identity of the thread wasn't corrupted.
            final long newIdent = Binder.clearCallingIdentity();
            if (ident != newIdent) {
                Log.wtf(TAG, "Thread identity changed from 0x"
                        + Long.toHexString(ident) + " to 0x"
                        + Long.toHexString(newIdent) + " while dispatching to "
                        + msg.target.getClass().getName() + " "
                        + msg.callback + " what=" + msg.what);
            }

            msg.recycleUnchecked();
        }

很明顯第1行用了一個死迴圈,第2行從queue中取出Message,第15行通過dispatchMessage(Message msg)方法將訊息傳送給Handler。

4.HandlerThread介紹

Android API解釋:

Handy class for starting a new thread that has a looper. The looper can then be used to create handler classes. Note that start() must still be called.

意思是說:這個類啟動一個新的執行緒並且建立一個Looper,這個Looper可以用來建立一個Handler類,完了之後一定要啟動這個執行緒。

什麼時候使用HandlerThread?

1.主執行緒需要通知子執行緒執行耗時操作(一般都是子執行緒執行耗時操作,完了之後,傳送訊息給主執行緒更新UI)。

2.開發中可能會多次建立匿名執行緒,這樣可能會消耗更多的系統資源。而HandlerThread自帶Looper使他可以通過訊息來多次重複使用當前執行緒，節省開支；

下面是HandlerThread應用部分程式碼:

private static final String TAG = "MainActivity";
    private static final int FLAG_TEST = 1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.i(TAG,"main thread:"+Thread.currentThread());
        HandlerThread thread = new HandlerThread("handler thread");
        thread.start();//一定要啟動該執行緒
        Handler handler = new Handler(thread.getLooper()){
            @Override
            public void handleMessage(Message msg) {
                Log.i(TAG,"handler thread:"+Thread.currentThread());
                switch (msg.what){
                    case FLAG_TEST:
                        //耗時操作...
                        break;
                    default:
                        break;
                }
                 super.handleMessage(msg);
            }
        };
        handler.sendEmptyMessage(FLAG_TEST);
    }

log:

com.example.administrator.handlertest I/MainActivity﹕ main thread:Thread[main,5,main]
com.example.administrator.handlertest I/MainActivity﹕ handler thread:Thread[handler thread,5,main]

通過log可以看出handler處在一個子執行緒中,這樣就能夠執行一些耗時操作。

第十一行通過thread.getLooper()來建立handler,那麼我們來看下getLooper()裡面的原始碼:

public Looper getLooper() {
        if (!isAlive()) {
            return null;
        }

        // If the thread has been started, wait until the looper has been created.
        synchronized (this) {
            while (isAlive() && mLooper == null) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
        }
        return mLooper;
    }

看第8行程式碼,如果這個執行緒可用並且looper為null時,就會呼叫wait()方法,處於等待狀態,這樣可以有效的避免多執行緒併發操作引起的空指標異常。在thread啟動時,會呼叫run()方法,再來看看run()方法裡面的程式碼:

@Override
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }

第4行建立了Looper物件,第6、7行獲取當前執行緒Looper之後呼叫notifyAll()方法。這時呼叫getLooper()方法返回一個Looper物件。

上面有提到使用HandlerThread避免多執行緒併發操作引起的空指標異常,這裡解釋下為什麼:如果onCreate方法第11行通過程式設計師自定義的一個新執行緒建立handler時,很可能出現這樣一個結果:建立handler的程式碼已經執行了,而新執行緒卻還沒有Looper.prepare()(建立Looper物件,那麼這樣就會導致空指標異常)。

對程式碼稍做修改:

package com.example.administrator.handlertest;

import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.support.v7.app.ActionBarActivity;
import android.util.Log;

public class MainActivity extends ActionBarActivity {

    private static final String TAG = "MainActivity";
    private static final int FLAG_TEST = 1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.i(TAG,"main thread:"+Thread.currentThread());
//        HandlerThread thread = new HandlerThread("handler thread");
//        thread.start();//一定要啟動該執行緒
        MyThread thread = new MyThread();
        thread.start();
        Handler handler = new Handler(thread.looper){
            @Override
            public void handleMessage(Message msg) {
                Log.i(TAG,"handler thread:"+Thread.currentThread());
                switch (msg.what){
                    case FLAG_TEST:
                        //耗時操作...
                        break;
                    default:
                        break;
                }
                 super.handleMessage(msg);
            }
        };
        handler.sendEmptyMessage(FLAG_TEST);
    }

    static class MyThread extends Thread{
        Looper looper;
        @Override
        public void run() {
            Looper.prepare();looper = Looper.myLooper();
            //...
            Looper.loop();
        }
    }
}

執行結果:

Caused by: java.lang.NullPointerException
            at android.os.Handler.<init>(Handler.java:234)
            at android.os.Handler.<init>(Handler.java:142)
            at com.example.administrator.handlertest.MainActivity$1.<init>(MainActivity.java:24)
            at com.example.administrator.handlertest.MainActivity.onCreate(MainActivity.java:24)
            at android.app.Activity.performCreate(Activity.java:5211)
            at android.app.Instrumentation.callActivityOnCreate(Instrumentation.java:1151)
            at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:2341)

從異常資訊第4行中可以看出:onCreate()方法第24行thread.looper是一個null.這時因為還沒等新執行緒建立Looper,Handler就已經建立了。如果在第23行thread.start()後面休眠幾秒就不會報空指標異常了。

最後補充一點,Android判斷當前更新UI的執行緒是否是主執行緒的物件ViewRootImpl物件在onResume()中,所以只要子執行緒在onResume()之前完成更新UI也是能夠實現的。這裡只是簡單提一下,知道就行,不過不要這麼做。

相關文章