全面總結Android中線程的非同步處理方式_Android

一、概述
Handler 、 Looper 、Message 這三者都與Android非同步訊息處理線程相關的概念。那麼什麼叫非同步訊息處理線程呢？
非同步訊息處理線程啟動後會進入一個無限的迴圈體之中，每迴圈一次，從其內部的訊息佇列中取出一個訊息，然後回調相應的訊息處理函數，執行完成一個訊息後則繼續迴圈。若訊息佇列為空白，線程則會阻塞等待。
說了這一堆，那麼和Handler 、 Looper 、Message有啥關係？其實Looper負責的就是建立一個MessageQueue，然後進入一個無限迴圈體不斷從該MessageQueue中讀取訊息，而訊息的建立者就是一個或多個Handler 。

二、源碼解析
1、Looper
對於Looper主要是prepare()和loop()兩個方法。
首先看prepare()方法

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

sThreadLocal是一個ThreadLocal對象，可以在一個線程中儲存變數。可以看到，在第5行，將一個Looper的執行個體放入了ThreadLocal，並且2-4行判斷了sThreadLocal是否為null，否則拋出異常。這也就說明了Looper.prepare()方法不能被調用兩次，同時也保證了一個線程中只有一個Looper執行個體~相信有些哥們一定遇到這個錯誤。
下面看Looper的構造方法：

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

在構造方法中，建立了一個MessageQueue（訊息佇列）。
然後我們看loop()方法：

public static void loop() {   final Looper me = myLooper();   if (me == null) {    throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");   }   final MessageQueue queue = me.mQueue;    // Make sure the identity of this thread is that of the local process,   // and keep track of what that identity token actually is.   Binder.clearCallingIdentity();   final long ident = Binder.clearCallingIdentity();    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.recycle();   } } 

第2行：

public static Looper myLooper() {return sThreadLocal.get();}

方法直接返回了sThreadLocal儲存的Looper執行個體，如果me為null則拋出異常，也就是說looper方法必須在prepare方法之後運行。
第6行：拿到該looper執行個體中的mQueue（訊息佇列）
13到45行：就進入了我們所說的無限迴圈。
14行：取出一條訊息，如果沒有訊息則阻塞。
27行：使用調用 msg.target.dispatchMessage(msg);把訊息交給msg的target的dispatchMessage方法去處理。Msg的target是什麼呢？其實就是handler對象，下面會進行分析。
44行：釋放訊息佔據的資源。

Looper主要作用：
（1）與當前線程綁定，保證一個線程只會有一個Looper執行個體，同時一個Looper執行個體也只有一個MessageQueue。
（2）loop()方法，不斷從MessageQueue中去取訊息，交給訊息的target屬性的dispatchMessage去處理。
好了，我們的非同步訊息處理線程已經有了訊息佇列（MessageQueue），也有了在無限迴圈體中取出訊息的哥們，現在缺的就是發送訊息的對象了，於是乎：Handler登場了。

2、Handler
使用Handler之前，我們都是初始化一個執行個體，比如用於更新UI線程，我們會在聲明的時候直接初始化，或者在onCreate中初始化Handler執行個體。所以我們首先看Handler的構造方法，看其如何與MessageQueue聯絡上的，它在子線程中發送的訊息（一般發送訊息都在非UI線程）怎麼發送到MessageQueue中的。

public Handler() {   this(null, false); } public Handler(Callback callback, boolean async) {   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());    }   }    mLooper = Looper.myLooper();   if (mLooper == null) {    throw new RuntimeException(     "Can't create handler inside thread that has not called Looper.prepare()");   }   mQueue = mLooper.mQueue;   mCallback = callback;   mAsynchronous = async;  } 

14行：通過Looper.myLooper()擷取了當前線程儲存的Looper執行個體，然後在19行又擷取了這個Looper執行個體中儲存的MessageQueue（訊息佇列），這樣就保證了handler的執行個體與我們Looper執行個體中MessageQueue關聯上了。

Handler 常用方法：

（1）post(Runnable)

（2）postAtTime(Runnable,long)

（3）postDelayed(Runnable long)

（4）sendEmptyMessage(int)

（5）sendMessage(Message)

（6）sendMessageAtTime(Message,long)

（7）sendMessageDelayed(Message,long)

以上post類方法允許你排列一個Runnable對象到主線程隊列中, sendMessage類方法, 允許你安排一個帶資料的Message對象到隊列中，等待更新.

一般運行邏輯：
點擊button --- > 啟動一條新線程,用來處理資料 ---- >資料處理完畢，通過handler返回 ----- > handler裡面接收返回的資料，進行UI更新等處理。

然後看我們最常用的sendMessage方法

public final boolean sendMessage(Message msg)  {   return sendMessageDelayed(msg, 0);  } public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {   Message msg = Message.obtain();   msg.what = what;   return sendMessageDelayed(msg, delayMillis);  } public final boolean sendMessageDelayed(Message msg, long delayMillis)  {   if (delayMillis < 0) {    delayMillis = 0;   }   return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);  } public boolean sendMessageAtTime(Message msg, long uptimeMillis) {   MessageQueue queue = mQueue;   if (queue == null) {    RuntimeException e = new RuntimeException(      this + " sendMessageAtTime() called with no mQueue");    Log.w("Looper", e.getMessage(), e);    return false;   }   return enqueueMessage(queue, msg, uptimeMillis);  } 

輾轉反則最後調用了sendMessageAtTime，在此方法內部有直接擷取MessageQueue然後調用了enqueueMessage方法，我們再來看看此方法：

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {   msg.target = this;   if (mAsynchronous) {    msg.setAsynchronous(true);   }   return queue.enqueueMessage(msg, uptimeMillis);  } 

enqueueMessage中首先為meg.target賦值為this，【如果大家還記得Looper的loop方法會取出每個msg然後交給msg,target.dispatchMessage(msg)去處理訊息】，也就是把當前的handler作為msg的target屬性。最終會調用queue的enqueueMessage的方法，也就是說handler發出的訊息，最終會儲存到訊息佇列中去。

現在已經很清楚了Looper會調用prepare()和loop()方法，在當前執行的線程中儲存一個Looper執行個體，這個執行個體會儲存一個MessageQueue對象，然後當前線程進入一個無限迴圈中去，不斷從MessageQueue中讀取Handler發來的訊息。然後再回調建立這個訊息的handler中的dispathMessage方法，下面我們趕快去看一看這個方法：

public void dispatchMessage(Message msg) {   if (msg.callback != null) {    handleCallback(msg);   } else {    if (mCallback != null) {     if (mCallback.handleMessage(msg)) {      return;     }    }    handleMessage(msg);   }  } 

可以看到，第10行，調用了handleMessage方法，下面我們去看這個方法：

/**  * Subclasses must implement this to receive messages.  */  public void handleMessage(Message msg) {  }  

可以看到這是一個空方法，為什麼呢，因為訊息的最終回調是由我們控制的，我們在建立handler的時候都是複寫handleMessage方法，然後根據msg.what進行訊息處理。
例如：

private Handler mHandler = new Handler()  {   public void handleMessage(android.os.Message msg)   {    switch (msg.what)    {    case value:          break;     default:     break;    }   };  }; 

到此，這個流程已經解釋完畢，讓我們首先總結一下
（1）首先Looper.prepare()在本線程中儲存一個Looper執行個體，然後該執行個體中儲存一個MessageQueue對象；因為Looper.prepare()在一個線程中只能調用一次，所以MessageQueue在一個線程中只會存在一個。
（2）Looper.loop()會讓當前線程進入一個無限迴圈，不端從MessageQueue的執行個體中讀取訊息，然後回調msg.target.dispatchMessage(msg)方法。
（3）Handler的構造方法，會首先得到當前線程中儲存的Looper執行個體，進而與Looper執行個體中的MessageQueue想關聯。
（4）Handler的sendMessage方法，會給msg的target賦值為handler自身，然後加入MessageQueue中。
（5）在構造Handler執行個體時，我們會重寫handleMessage方法，也就是msg.target.dispatchMessage(msg)最終調用的方法。
好了，總結完成，大家可能還會問，那麼在Activity中，我們並沒有顯示的調用Looper.prepare()和Looper.loop()方法，為啥Handler可以成功建立呢，這是因為在Activity的啟動代碼中，已經在當前UI線程調用了Looper.prepare()和Looper.loop()方法。

3、Handler post
今天有人問我，你說Handler的post方法建立的線程和UI線程有什麼關係？
其實這個問題也是出現這篇部落格的原因之一；這裡需要說明，有時候為了方便，我們會直接寫如下代碼：

mHandler.post(new Runnable()   {    @Override    public void run()    {     Log.e("TAG", Thread.currentThread().getName());     mTxt.setText("yoxi");    }   }); 

然後run方法中可以寫更新UI的代碼，其實這個Runnable並沒有建立什麼線程，而是發送了一條訊息，下面看源碼：

public final boolean post(Runnable r)  {   return sendMessageDelayed(getPostMessage(r), 0);  } private static Message getPostMessage(Runnable r) {   Message m = Message.obtain();   m.callback = r;   return m;  } 

可以看到，在getPostMessage中，得到了一個Message對象，然後將我們建立的Runable對象作為callback屬性，賦值給了此message.
註：產生一個Message對象，可以new  ，也可以使用Message.obtain()方法；兩者都可以，但是更建議使用obtain方法，因為Message內部維護了一個Message池用於Message的複用，避免使用new 重新分配記憶體。

public final boolean sendMessageDelayed(Message msg, long delayMillis)  {   if (delayMillis < 0) {    delayMillis = 0;   }   return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);  } public boolean sendMessageAtTime(Message msg, long uptimeMillis) {   MessageQueue queue = mQueue;   if (queue == null) {    RuntimeException e = new RuntimeException(      this + " sendMessageAtTime() called with no mQueue");    Log.w("Looper", e.getMessage(), e);    return false;   }   return enqueueMessage(queue, msg, uptimeMillis);  } 

最終和handler.sendMessage一樣，調用了sendMessageAtTime，然後調用了enqueueMessage方法，給msg.target賦值為handler，最終加入MessagQueue.
可以看到，這裡msg的callback和target都有值，那麼會執行哪個呢？
其實上面已經貼過代碼，就是dispatchMessage方法：

public void dispatchMessage(Message msg) {   if (msg.callback != null) {    handleCallback(msg);   } else {    if (mCallback != null) {     if (mCallback.handleMessage(msg)) {      return;     }    }    handleMessage(msg);   }  } 

 
第2行，如果不為null，則執行callback回調，也就是我們的Runnable對象。

好了，關於Looper , Handler , Message 這三者關係上面已經敘述的非常清楚了。
最後來張圖解：

希望圖片可以更好的協助大家的記憶~~

三、補充
其實Handler不僅可以更新UI，你完全可以在一個子線程中去建立一個Handler，然後使用這個handler執行個體在任何其他線程中發送訊息，最終處理訊息的代碼都會在你建立Handler執行個體的線程中運行。

eg：

new Thread()   {    private Handler handler;    public void run()    {      Looper.prepare();          handler = new Handler()     {      public void handleMessage(android.os.Message msg)      {       Log.e("TAG",Thread.currentThread().getName());      };     }  }

Android不僅給我們提供了非同步訊息處理機制讓我們更好的完成UI的更新，其實也為我們提供了非同步訊息處理機制代碼的參考~~不僅能夠知道原理，最好還可以將此設計用到其他的非Android項目中去~~