Android的消息處理機制（圖+源碼分析）——Looper,Handler,Message

時間  2019-11-06
標籤 android 消息 處理 機制 源碼 分析 looper handler message 欄目 Android 简体版
原文   原文鏈接

做爲一個大三的預備程序員，我學習android的一大樂趣是能夠經過源碼學習google大牛們的設計思想。android源碼中包含了大量的設 計模式，除此之外，android sdk還精心爲咱們設計了各類helper類，對於和我同樣渴望水平獲得進階的人來講，都太值得一讀了。這不，前幾天爲了瞭解android的消息處理機 制，我看了Looper，Handler，Message這幾個類的源碼，結果又一次被googler的設計震撼了，特與你們分享。 html

android的消息處理有三個核心類：Looper,Handler和Message。其實還有一個Message Queue（消息隊列），可是MQ被封裝到Looper裏面了，咱們不會直接與MQ打交道，所以我沒將其做爲核心類。下面一一介紹： java

線程的魔法師 Looper

Looper的字面意思是「循環者」，它被設計用來使一個普通線程變成Looper線程。所謂Looper線程就是循環工做的線程。在程序開發中（尤爲是GUI開發中），咱們常常會須要一個線程不斷循環，一旦有新任務則執行，執行完繼續等待下一個任務，這就是Looper線程。使用Looper類建立Looper線程很簡單： android

public class LooperThread extends Thread {
    @Override
    public void run() {
        // 將當前線程初始化爲Looper線程
        Looper.prepare();
        
        // ...其餘處理，如實例化handler
        
        // 開始循環處理消息隊列
        Looper.loop();
    }
}

經過上面兩行核心代碼，你的線程就升級爲Looper線程了！！！是否是很神奇？讓咱們放慢鏡頭，看看這兩行代碼各自作了什麼。 程序員

1)Looper.prepare() app

經過上圖能夠看到，如今你的線程中有一個Looper對象，它的內部維護了一個消息隊列MQ。注意，一個Thread只能有一個Looper對象，爲何呢？我們來看源碼。 異步

public class Looper {
    // 每一個線程中的Looper對象實際上是一個ThreadLocal，即線程本地存儲(TLS)對象
    private static final ThreadLocal sThreadLocal = new ThreadLocal();
    // Looper內的消息隊列
    final MessageQueue mQueue;
    // 當前線程
    Thread mThread;
    // 。。。其餘屬性

    // 每一個Looper對象中有它的消息隊列，和它所屬的線程
    private Looper() {
        mQueue = new MessageQueue();
        mRun = true;
        mThread = Thread.currentThread();
    }

    // 咱們調用該方法會在調用線程的TLS中建立Looper對象
    public static final void prepare() {
        if (sThreadLocal.get() != null) {
            // 試圖在有Looper的線程中再次建立Looper將拋出異常
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper());
    }
    // 其餘方法
}

經過源碼，prepare()背後的工做方式一目瞭然，其核心就是將looper對象定義爲ThreadLocal。若是你還不清楚什麼是ThreadLocal，請參考《理解ThreadLocal》  《正確理解ThreadLocal》。 ide

2）Looper.loop() oop

調用loop方法後，Looper線程就開始真正工做了，它不斷從本身的MQ中取出隊頭的消息(也叫任務)執行。其源碼分析以下： 源碼分析

public static final void loop() {
        Looper me = myLooper();  //獲得當前線程Looper
        MessageQueue queue = me.mQueue;  //獲得當前looper的MQ
        
        // 這兩行沒看懂= = 不過不影響理解
        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();
        // 開始循環
        while (true) {
            Message msg = queue.next(); // 取出message
            if (msg != null) {
                if (msg.target == null) {
                    // message沒有target爲結束信號，退出循環
                    return;
                }
                // 日誌。。。
                if (me.mLogging!= null) me.mLogging.println(
                        ">>>>> Dispatching to " + msg.target + " "
                        + msg.callback + ": " + msg.what
                        );
                // 很是重要！將真正的處理工做交給message的target，即後面要講的handler
                msg.target.dispatchMessage(msg);
                // 仍是日誌。。。
                if (me.mLogging!= null) me.mLogging.println(
                        "<<<<< Finished to    " + msg.target + " "
                        + msg.callback);
                
                // 下面沒看懂，一樣不影響理解
                final long newIdent = Binder.clearCallingIdentity();
                if (ident != newIdent) {
                    Log.wtf("Looper", "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);
                }
                // 回收message資源
                msg.recycle();
            }
        }
    }

除了prepare()和loop()方法，Looper類還提供了一些有用的方法，好比 post

Looper.myLooper()獲得當前線程looper對象： 

public static final Looper myLooper() {
        // 在任意線程調用Looper.myLooper()返回的都是那個線程的looper
        return (Looper)sThreadLocal.get();
    }
getThread()獲得looper對象所屬線程： 
public Thread getThread() {
        return mThread;
    }
quit()方法結束looper循環： 
public void quit() {
        // 建立一個空的message，它的target爲NULL，表示結束循環消息
        Message msg = Message.obtain();
        // 發出消息
        mQueue.enqueueMessage(msg, 0);
    }

到此爲止，你應該對Looper有了基本的瞭解，總結幾點：

1.每一個線程有且最多隻能有一個Looper對象，它是一個ThreadLocal

2.Looper內部有一個消息隊列，loop()方法調用後線程開始不斷從隊列中取出消息執行

3.Looper使一個線程變成Looper線程。

那麼，咱們如何往MQ上添加消息呢？下面有請Handler！（掌聲~~~）

異步處理大師 Handler

什麼是handler？handler扮演了往MQ上添加消息和處理消息的角色（只處理由本身發出的消息），即通知MQ它要執行一個任務(sendMessage)，並在loop到本身的時候執行該任務(handleMessage)，整個過程是異步的。handler建立時會關聯一個looper，默認的構造方法將關聯當前線程的looper，不過這也是能夠set的。默認的構造方法： 

public class handler {

    final MessageQueue mQueue;  // 關聯的MQ
    final Looper mLooper;  // 關聯的looper
    final Callback mCallback; 
    // 其餘屬性

    public Handler() {
        // 沒看懂，直接略過，，，
        if (FIND_POTENTIAL_LEAKS) {
            final Class<? extends Handler> klass = getClass();
            if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                    (klass.getModifiers() & Modifier.STATIC) == 0) {
                Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                    klass.getCanonicalName());
            }
        }
        // 默認將關聯當前線程的looper
        mLooper = Looper.myLooper();
        // looper不能爲空，即該默認的構造方法只能在looper線程中使用
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        // 重要！！！直接把關聯looper的MQ做爲本身的MQ，所以它的消息將發送到關聯looper的MQ上
        mQueue = mLooper.mQueue;
        mCallback = null;
    }
    
    // 其餘方法
}
下面咱們就能夠爲以前的LooperThread類加入Handler： 
public class LooperThread extends Thread {
    private Handler handler1;
    private Handler handler2;

    @Override
    public void run() {
        // 將當前線程初始化爲Looper線程
        Looper.prepare();
        
        // 實例化兩個handler
        handler1 = new Handler();
        handler2 = new Handler();
        
        // 開始循環處理消息隊列
        Looper.loop();
    }
}

加入handler後的效果以下圖：

能夠看到，一個線程能夠有多個Handler，可是隻能有一個Looper！

Handler發送消息

有了handler以後，咱們就可使用post(Runnable),postAtTime(Runnable, long),postDelayed(Runnable, long),sendEmptyMessage(int),sendMessage(Message),sendMessageAtTime(Message, long)和sendMessageDelayed(Message, long)這些方法向MQ上發送消息了。光看這些API你可能會以爲handler能發兩種消息，一種是Runnable對象，一種是message對象，這是直觀的理解，但其實post發出的Runnable對象最後都被封裝成message對象了，見源碼： 

// 此方法用於向關聯的MQ上發送Runnable對象，它的run方法將在handler關聯的looper線程中執行
    public final boolean post(Runnable r)
    {
       // 注意getPostMessage(r)將runnable封裝成message
       return  sendMessageDelayed(getPostMessage(r), 0);
    }

    private final Message getPostMessage(Runnable r) {
        Message m = Message.obtain();  //獲得空的message
        m.callback = r;  //將runnable設爲message的callback，
        return m;
    }

    public boolean sendMessageAtTime(Message msg, long uptimeMillis)
    {
        boolean sent = false;
        MessageQueue queue = mQueue;
        if (queue != null) {
            msg.target = this;  // message的target必須設爲該handler！
            sent = queue.enqueueMessage(msg, uptimeMillis);
        }
        else {
            RuntimeException e = new RuntimeException(
                this + " sendMessageAtTime() called with no mQueue");
            Log.w("Looper", e.getMessage(), e);
        }
        return sent;
    }

其餘方法就不羅列了，總之經過handler發出的message有以下特色：

1.message.target爲該handler對象，這確保了looper執行到該message時能找處處理它的handler，即loop()方法中的關鍵代碼 

msg.target.dispatchMessage(msg);

2.post發出的message，其callback爲Runnable對象

Handler處理消息

說完了消息的發送，再來看下handler如何處理消息。消息的處理是經過核心方法dispatchMessage(Message msg)與鉤子方法handleMessage(Message msg)完成的，見源碼 

// 處理消息，該方法由looper調用
    public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            // 若是message設置了callback，即runnable消息，處理callback！
            handleCallback(msg);
        } else {
            // 若是handler自己設置了callback，則執行callback
            if (mCallback != null) {
                 /* 這種方法容許讓activity等來實現Handler.Callback接口，避免了本身編寫handler重寫handleMessage方法。見http://alex-yang-xiansoftware-com.iteye.com/blog/850865 */
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            // 若是message沒有callback，則調用handler的鉤子方法handleMessage
            handleMessage(msg);
        }
    }
    
    // 處理runnable消息
    private final void handleCallback(Message message) {
        message.callback.run();  //直接調用run方法！
    }
    // 由子類實現的鉤子方法
    public void handleMessage(Message msg) {
    }

能夠看到，除了handleMessage(Message msg)和Runnable對象的run方法由開發者實現外（實現具體邏輯），handler的內部工做機制對開發者是透明的。這正是handler API設計的精妙之處！

Handler的用處

我在小標題中將handler描述爲「異步處理大師」，這歸功於Handler擁有下面兩個重要的特色：

1.handler能夠在任意線程發送消息，這些消息會被添加到關聯的MQ上。

              

2.handler是在它關聯的looper線程中處理消息的。

這就解決了android最經典的不能在其餘非主線程中更新UI的問題。android的主線程也是一個looper線程(looper 在android中運用很廣)，咱們在其中建立的handler默認將關聯主線程MQ。所以，利用handler的一個solution就是在 activity中建立handler並將其引用傳遞給worker thread，worker thread執行完任務後使用handler發送消息通知activity更新UI。(過程如圖)

下面給出sample代碼，僅供參考： 

public class TestDriverActivity extends Activity {
    private TextView textview;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        textview = (TextView) findViewById(R.id.textview);
        // 建立並啓動工做線程
        Thread workerThread = new Thread(new SampleTask(new MyHandler()));
        workerThread.start();
    }
    
    public void appendText(String msg) {
        textview.setText(textview.getText() + "\n" + msg);
    }
    
    class MyHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            String result = msg.getData().getString("message");
            // 更新UI
            appendText(result);
        }
    }
}



public class SampleTask implements Runnable {
    private static final String TAG = SampleTask.class.getSimpleName();
    Handler handler;
    
    public SampleTask(Handler handler) {
        super();
        this.handler = handler;
    }

    @Override
    public void run() {
        try {  // 模擬執行某項任務，下載等
            Thread.sleep(5000);
            // 任務完成後通知activity更新UI
            Message msg = prepareMessage("task completed!");
            // message將被添加到主線程的MQ中
            handler.sendMessage(msg);
        } catch (InterruptedException e) {
            Log.d(TAG, "interrupted!");
        }

    }

    private Message prepareMessage(String str) {
        Message result = handler.obtainMessage();
        Bundle data = new Bundle();
        data.putString("message", str);
        result.setData(data);
        return result;
    }

}

固然，handler能作的遠遠不只如此，因爲它能post Runnable對象，它還能與Looper配合實現經典的Pipeline Thread(流水線線程)模式。請參考此文《Android Guts: Intro to Loopers and Handlers》

封裝任務 Message

在整個消息處理機制中，message又叫task，封裝了任務攜帶的信息和處理該任務的handler。message的用法比較簡單，這裏不作總結了。可是有這麼幾點須要注意（待補充）：

1.儘管Message有public的默認構造方法，可是你應該經過Message.obtain()來從消息池中得到空消息對象，以節省資源。

2.若是你的message只須要攜帶簡單的int信息，請優先使用Message.arg1和Message.arg2來傳遞信息，這比用Bundle更省內存

3.擅用message.what來標識信息，以便用不一樣方式處理message。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程