前言

很明顯的一點就是，我們要在子執行緒中呼叫Looper.prepare() 為一個執行緒開啟一個訊息迴圈，預設情況下Android中新誕生的執行緒是沒有開啟訊息迴圈的。（主執行緒除外，主執行緒系統會自動為其建立Looper物件，開啟訊息迴圈。） Looper物件通過MessageQueue來存放訊息和事件。一個執行緒只能有一個Looper，對應一個MessageQueue。 然後通過Looper.loop() 讓Looper開始工作，從訊息佇列裡取訊息，處理訊息。

注意：寫在Looper.loop()之後的程式碼不會被執行，這個函式內部應該是一個迴圈，當呼叫mHandler.getLooper().quit()後，loop才會中止，其後的程式碼才能得以執行。

然而這一切都可以用HandlerThread類來幫我們做這些邏輯操作。

HandlerThread

HandlerThread本質上就是一個普通Thread,只不過內部建立了Looper.

HandlerThread的常規用法

• 建立一個HandlerThread

mThread = new HandlerThread("handler_thread");

• 啟動一個HandlerThread

  mThread.start();

• 退出迴圈 Looper是通過呼叫loop方法驅動著訊息迴圈的進行: 從MessageQueue中阻塞式地取出一個訊息，然後讓Handler處理該訊息，周而復始，loop方法是個死迴圈方法。

那如何終止訊息迴圈呢？我們可以呼叫Looper的quit方法或quitSafely方法，二者稍有不同。

 /**
     * Quits the looper.
     * <p>
     * Causes the {@link #loop} method to terminate without processing any
     * more messages in the message queue.
     * </p><p>
     * Any attempt to post messages to the queue after the looper is asked to quit will fail.
     * For example, the {@link Handler#sendMessage(Message)} method will return false.
     * </p><p class="note">
     * Using this method may be unsafe because some messages may not be delivered
     * before the looper terminates.  Consider using {@link #quitSafely} instead to ensure
     * that all pending work is completed in an orderly manner.
     * </p>
     *
     * @see #quitSafely
     */
    public void quit() {
        mQueue.quit(false);
    }

    /**
     * Quits the looper safely.
     * <p>
     * Causes the {@link #loop} method to terminate as soon as all remaining messages
     * in the message queue that are already due to be delivered have been handled.
     * However pending delayed messages with due times in the future will not be
     * delivered before the loop terminates.
     * </p><p>
     * Any attempt to post messages to the queue after the looper is asked to quit will fail.
     * For example, the {@link Handler#sendMessage(Message)} method will return false.
     * </p>
     */
    public void quitSafely() {
        mQueue.quit(true);
    }
 

相同點： 將不在接受新的事件加入訊息佇列。

不同點 當我們呼叫Looper的quit方法時，實際上執行了MessageQueue中的removeAllMessagesLocked方法，該方法的作用是把MessageQueue訊息池中所有的訊息全部清空，無論是延遲訊息（延遲訊息是指通過sendMessageDelayed或通過postDelayed等方法傳送的需要延遲執行的訊息）還是非延遲訊息。

當我們呼叫Looper的quitSafely方法時，實際上執行了MessageQueue中的removeAllFutureMessagesLocked方法，通過名字就可以看出，該方法只會清空MessageQueue訊息池中所有的延遲訊息，並將訊息池中所有的非延遲訊息派發出去讓Handler去處理，quitSafely相比於quit方法安全之處在於清空訊息之前會派發所有的非延遲訊息。

無論是呼叫了quit方法還是quitSafely方法只會，Looper就不再接收新的訊息。即在呼叫了Looper的quit或quitSafely方法之後，訊息迴圈就終結了，這時候再通過Handler呼叫sendMessage或post等方法傳送訊息時均返回false，表示訊息沒有成功放入訊息佇列MessageQueue中，因為訊息佇列已經退出了。

需要注意的是Looper的quit方法從API Level 1就存在了，但是Looper的quitSafely方法從API Level 18才新增進來。

小例子：

package com.app;

import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;

public class MainActivity extends AppCompatActivity {

    private HandlerThread myHandlerThread ;
    private Handler handler ;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //建立一個執行緒,執行緒名字：handler-thread
        myHandlerThread = new HandlerThread( "handler-thread") ;
        //開啟一個執行緒
        myHandlerThread.start();
        //在這個執行緒中建立一個handler物件
        handler = new Handler( myHandlerThread.getLooper() ){
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                //這個方法是執行在 handler-thread 執行緒中的 ，可以執行耗時操作
                Log.d( "handler " , "訊息： " + msg.what + "  執行緒： " + Thread.currentThread().getName()  ) ;

            }
        };

        //在主執行緒給handler傳送訊息
        handler.sendEmptyMessage( 1 ) ;

        new Thread(new Runnable() {
            @Override
            public void run() {
             //在子執行緒給handler傳送資料
             handler.sendEmptyMessage( 2 ) ;
            }
        }).start() ;

    }

    @Override
    protected void onDestroy() {
        super.onDestroy();

        //釋放資源
        myHandlerThread.quit() ;
    }
}

執行效果：

/com.app D/handler: 訊息： 1  執行緒： handler-thread
/com.app D/handler: 訊息： 2  執行緒： handler-thread

HandlerThread的特點

• HandlerThread將loop轉到子執行緒中處理，說白了就是將分擔MainLooper的工作量，降低了主執行緒的壓力，使主介面更流暢。

• 開啟一個執行緒起到多個執行緒的作用。處理任務是序列執行，按訊息傳送順序進行處理。HandlerThread本質是一個執行緒，線上程內部，程式碼是序列處理的。

• 但是由於每一個任務都將以佇列的方式逐個被執行到，一旦佇列中有某個任務執行時間過長，那麼就會導致後續的任務都會被延遲處理。

• HandlerThread擁有自己的訊息佇列，它不會干擾或阻塞UI執行緒。

• 對於網路IO操作，HandlerThread並不適合，因為它只有一個執行緒，還得排隊一個一個等著。

參考文章：