Android Looper Handler 和Message

android源碼中包含了大量的設計模式，除此以外，android sdk還精心爲我們設計了各種helper類，對於和我一樣渴望水平得到進階的人來說，都太值得一讀了。這不，前幾天爲了瞭解android的消息處理機制，我看了Looper，Handler，Message這幾個類的源碼，結果又一次被google的設計震撼了，特與大家分享。
android的消息處理有三個核心類：Looper,Handler和Message。其實還有一個Message Queue（消息隊列），但是MQ被封裝到Looper裏面了，我們不會直接與MQ打交道，因此我沒將其作爲核心類。下面一一介紹：

線程的魔法師 Looper

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

public class LooperThread extends Thread {
    @Override
publicvoid run() {
// 將當前線程初始化爲Looper線程
        Looper.prepare();

// ...其他處理，如實例化handler

// 開始循環處理消息隊列
        Looper.loop();
    }
}

複製代碼
通過上面兩行核心代碼，你的線程就升級爲Looper線程了！！！是不是很神奇？讓我們放慢鏡頭，看看這兩行代碼各自做了什麼。
1)查看Looper源碼：

publicclass 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將拋出異常
thrownew RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper());
    }
// 其他方法
}

public static final void loop() {
        Looper me = myLooper();  //得到當前線程Looper
        MessageQueue queue = me.mQueue;  //得到當前looper的MQ

// 這兩行沒看懂= = 不過不影響理解
        Binder.clearCallingIdentity();
finallong 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);

// 下面沒看懂，同樣不影響理解
finallong 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類還提供了一些有用的方法，比如
Looper.myLooper()得到當前線程looper對象：

publicstaticfinal Looper myLooper() {
// 在任意線程調用Looper.myLooper()返回的都是那個線程的looper
return (Looper)sThreadLocal.get();
}
getThread()得到looper對象所屬線程：

public Thread getThread() {
return mThread;
}
quit()方法結束looper循環：

publicvoid 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) {
thrownew 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
publicvoid run() {
// 將當前線程初始化爲Looper線程
        Looper.prepare();

// 實例化兩個handler
        handler1 = new Handler();
        handler2 = new Handler();

// 開始循環處理消息隊列
        Looper.loop();
    }

一個線程可以有多個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對象了

通過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調用
publicvoid 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消息
privatefinalvoid handleCallback(Message message) {
        message.callback.run();  //直接調用run方法！
    }
// 由子類實現的鉤子方法
publicvoid handleMessage(Message msg) {
    }

封裝任務 Message

在整個消息處理機制中，message又叫task，封裝了任務攜帶的信息和處理該任務的handler。message的用法比較簡單，這裏不做總結了。但是有這麼幾點需要注意（待補充）：
1.儘管Message有public的默認構造方法，但是你應該通過Message.obtain()來從消息池中獲得空消息對象，以節省資源。
2.如果你的message只需要攜帶簡單的int信息，請優先使用Message.arg1和Message.arg2來傳遞信息，這比用Bundle更省內存
3.擅用message.what來標識信息，以便用不同方式處理message。

Android多線程
Android的消息傳遞機制是另外一種形式的“事件處理”，這種機制主要是爲了解決Android應用中多線程的問題，在Android中不允許Activity新啓動的線程訪問該Activity裏的UI組件，這樣會導致新啓動的線程無法改變UI組件的屬性值。但實際開發中，很多地方需要在工作線程中改變UI組件的屬性值，比如下載網絡圖片、動畫等等。本篇博客主要介紹Handler是如何發送與處理線程上傳遞來的消息，並講解 Message的幾種傳遞數據的方式，最後均會以小Demo來演示。

Handler
Handler，它直接繼承自Object，一個Handler允許發送和處理Message或者Runnable對象，並且會關聯到主線程的MessageQueue 中。每個Handler具有一個單獨的線程，並且關聯到一個消息隊列的線程，就是說一個Handler有一個固有的消息隊列。當實例化一個Handler 的時候，它就承載在一個線程和消息隊列的線程，這個Handler可以把Message或Runnable壓入到消息隊列，並且從消息隊列中取出 Message或Runnable，進而操作它們。
　　Handler主要有兩個作用：
在工作線程中發送消息。
在UI線程中獲取、處理消息。
　　上面介紹到Handler可以把一個Message對象或者Runnable對象壓入到消息隊列中，進而在UI線程中獲取Message或者執行Runnable對象，所以Handler把壓入消息隊列有兩大體系，Post和sendMessage：
Post：Post允許把一個Runnable對象入隊到消息隊列中。它的方法有：post(Runnable)、postAtTime(Runnable,long)、postDelayed(Runnable,long)。
sendMessage：sendMessage允許把一個包含消息數據的Message對象壓入到消息隊列中。它的方法有：sendEmptyMessage(int)、sendMessage(Message)、 sendMessageAtTime(Message,long)、sendMessageDelayed(Message,long)。
　　從上面的各種方法可以看出，不管是post還是sendMessage都具有多種方法，它們可以設定Runnable對象和Message對象被入隊到消息隊列中，是立即執行還是延遲執行。

Post
　　對於Handler的Post方式來說，它會傳遞一個Runnable對象到消息隊列中，在這個Runnable對象中，重寫run()方法。一般在這個run()方法中寫入需要在UI線程上的操作。
　　在Handler中，關於Post方式的方法有：
boolean post(Runnable r)：把一個Runnable入隊到消息隊列中，UI線程從消息隊列中取出這個對象後，立即執行。
boolean postAtTime(Runnable r,long uptimeMillis)：把一個Runnable入隊到消息隊列中，UI線程從消息隊列中取出這個對象後，在特定的時間執行。
boolean postDelayed(Runnable r,long delayMillis)：把一個Runnable入隊到消息隊列中，UI線程從消息隊列中取出這個對象後，延遲delayMills秒執行
void removeCallbacks(Runnable r)：從消息隊列中移除一個Runnable對象。

Message
　　Handler如果使用sendMessage的方式把消息入隊到消息隊列中，需要傳遞一個Message對象，而在Handler中，需要重寫handleMessage()方法，用於獲取工作線程傳遞過來的消息，此方法運行在UI線程上。下面先介紹一下Message。
Message是一個final類，所以不可被繼承。Message封裝了線程中傳遞的消息，如果對於一般的數據，Message提供了getData()和setData()方法來獲取與設置數據，其中操作的數據是一個Bundle對象，這個Bundle對象提供一系列的getXxx()和setXxx()方法用於傳遞基本數據類型的鍵值對，對於基本數據類型，使用起來很簡單，這裏不再詳細講解。而對於複雜的數據類型，如一個對象的傳遞就要相對複雜一些。在Bundle中提供了兩個方法，專門用來傳遞對象的，但是這兩個方法也有相應的限制，需要實現特定的接口，當然，一些Android自帶的類，其實已經實現了這兩個接口中的某一個，可以直接使用。方法如下：
putParcelable(String key,Parcelable value)：需要傳遞的對象類實現Parcelable接口。
pubSerializable(String key,Serializable value)：需要傳遞的對象類實現Serializable接口。
　　還有另外一種方式在Message中傳遞對象，那就是使用Message自帶的obj屬性傳值，它是一個Object類型，所以可以傳遞任意類型的對象，Message自帶的有如下幾個屬性：
int arg1：參數一，用於傳遞不復雜的數據，複雜數據使用setData()傳遞。
int arg2：參數二，用於傳遞不復雜的數據，複雜數據使用setData()傳遞。
Object obj：傳遞一個任意的對象。
int what：定義的消息碼，一般用於設定消息的標誌。
　　對於Message對象，一般並不推薦直接使用它的構造方法得到，而是建議通過使用Message.obtain()這個靜態的方法或者 Handler.obtainMessage()獲取。Message.obtain()會從消息池中獲取一個Message對象，如果消息池中是空的，纔會使用構造方法實例化一個新Message，這樣有利於消息資源的利用。並不需要擔心消息池中的消息過多，它是有上限的，上限爲10個。 Handler.obtainMessage()具有多個重載方法，如果查看源碼，會發現其實Handler.obtainMessage()在內部也是調用的Message.obtain()。　

異步操作主要是用於處理耗時的操作，從而提供程序的用戶體驗。如下是對AsynTask

Android Looper Handler 和Message

線程的魔法師 Looper

異步處理大師 Handler

Spring Cloud 部署時如何使用 Kubernetes 作爲註冊中心和配置中心

【android基礎一】Android四大基本組件介紹與生命週期

【android基礎三】Android中SQLite應用詳解

Unity3D讓攝像機隨player移動

android中singleTask的home鍵的問題

Getting started with JRebel for Android

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結