Handler 原理分析和使用之HandlerThread

前面已經提到過Handler的原理以及Handler的三種用法。這里做一個非常簡單的一個總結：

• Handler 是跨線程的Message處理。負責把Message推送到MessageQueue和處理。
• Looper 用來輪詢MessageQueue，獲取Message 發送給指定的Handler進行處理。
• Looper 需要和線程綁定，綁定那個線程，Handler就會在那個線程處理Message

前兩篇文章使用Handler處理的場景是：主線程（UI線程）被子線程更新。即使用主線程的Handler和Looper，在子線程中發Message。然后主線程處理 handlerMessage。

-----------------------------------------------------------------------------------------

下面反過來說，如何從UI線程發消息，讓子線程處理。

最為通常的做法是：new Thread().start。起一個線程去完成一個任務，任務完成線程就可以自斃了。當然了如果不需要子線程返回結果，而且只有一個線程，那么這是最簡單的了。

另一種方法是SyncTask。實例如下：

import android.os.AsyncTask;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;


public class MainActivity extends AppCompatActivity implements View.OnClickListener{

    private TextView myTextView;
    private Button myButton;
    private MyAsyncTask myTask;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        myTextView = (TextView)this.findViewById(R.id.text_view);
        myButton = (Button)this.findViewById(R.id.post);
        myButton.setOnClickListener(this);
        //主線程初始化異步任務
        myTask = new MyAsyncTask();
        //主線程啟動異步任務，
        myTask.execute(10);
    }

    @Override
    public void onClick(View v) {
        //主線程取消異步任務
        myTask.cancel(true);
    }

    /**
     * AsyncTask<T, Q, K> 是異步任務基類  包含三個泛型參數。
     * T 類型參數為執行異步任務時的參數類型doInBackground(T)
     * Q 類型參數為執行過程中的參數類型onProgressUpdate(Q)
     * K 類型參數為執行結束onPostExecute(K)或中取消執行時的類型參數onCancelled(K)
     */
    class MyAsyncTask  extends AsyncTask<Integer, Integer, Long>{

        @Override
        //執行異步任務核心方法，主語T參數類型
        protected Long doInBackground(Integer... params) {
            int size = params[0];
            long totalSize = 0l;
            for(int i = 0; i < size; i++){
                totalSize += 10000;
                publishProgress((int) ((i / (float) size) * 100));
                if(isCancelled()){
                    break;
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return totalSize;
        }

        @Override
        //開始執行異步任務前，更新UI線程。
        protected void onPreExecute() {
            myTextView.setText("downLoad start !!");
        }

        @Override
        //執行異步任務中，更新UI線程
        protected void onProgressUpdate(Integer... values) {
            int progress = values[0];
            myTextView.setText(progress + "%");
        }

        @Override
        //執行異步任務后，更新UI線程
        protected void onPostExecute(Long aLong) {
            myTextView.setText("Task finished");
        }

        @Override
        //執行異步任務被取消后，跟新UI線程
        protected void onCancelled(Long aLong) {
            myTextView.setText("Task camcelled");
        }
    }
}

 

通過實例可以看出，SyncTask不但可以給主線程提供啟動和停止接口，還可以給主線程上報過程。當然了開銷也是有的。

實際上這種方式也可以用 Handler 原理分析和使用（一）中的例子實現。

 

以上都是主線程啟動一個子線程完成任務。但是如果要做多個異步任務，該如何實現？

首先，從多個異步任務來考慮，如果還是各自不同的話，先考慮到的是線程池。這個在后面的多線程部分在說明。

還有一種方式就是使用HandlerThread。這個就是通過主線程獲取其他線程給HandlerThread發消息，使其完成相關的任務。在例舉說明HandlerThread使用之前，先看看以下例子。也是主線程給子線程發消息，讓子線程處理任務。

import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;


public class MainActivity extends AppCompatActivity implements View.OnClickListener{

    private TextView myTextView;
    private Button myButton;
    private MyThread myThread;
    private Handler myThreadHandler;
    private int count = 0;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        myTextView = (TextView)this.findViewById(R.id.text_view);
        myButton = (Button)this.findViewById(R.id.post);
        myButton.setOnClickListener(this);
        //定義子線程
        myThread = new MyThread();
        //獲取子線程的Handler
        myThreadHandler = myThread.getHandler();
        //啟動子線程
        myThread.start();

    }

    @Override
    public void onClick(View v) {
        count++;
        //通過子線程的Handler，主線程給子線程發送消息（添加任務）
        myThreadHandler.sendEmptyMessage(count);
    }

    /**
     * 子線程
     */
    public class MyThread extends Thread{
        public Handler mThreadHandler = null;
        //任務隊列
        public BlockingQueue<Integer> queue  = null;
        public MyThread(){
            super();
            queue  = new ArrayBlockingQueue<Integer>(20);
            //獲取子線程的Looper
            Looper mThreadLopper = Looper.myLooper();
            //初始化子線程的Handler
            mThreadHandler = new Handler(mThreadLopper, new Handler.Callback() {
                @Override
                //接收到主線程發的任務
                public boolean handleMessage(Message msg) {
                    //任務添加到隊列
                    queue.add(msg.what);
                    return false;
                }
            });
        }
        public Handler getHandler(){
            return mThreadHandler;
        }
        public void run(){
            while(true){
                try{
                    //任務的處理
                    int what = queue.take();
                    Log.e("Test", "Click Button = " + what);
                }catch(InterruptedException e){

                }

            }
        }

    }
}

上面的例子說明了兩件事情。第一，非主線程有自己的Looper（很多文章說沒有），第二Handler可以處理非主線程的任務。實際上上面的例子，使用了sendMessage()方法，其實際上用處並不是很廣泛，甚至有些憋屈，本身已經有了一個MessageQueue，為什么還要使用一個ArrayBlockingQueue？

實際上上述的例子，完全可以通過HandlerThread來替代。例子如下

import android.os.Handler;
import android.os.HandlerThread;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity implements View.OnClickListener{

    public TextView myTextView;
    private Button myButton;
    private HandlerThread myThread;
    private Handler myThreadHandler;
    private int count = 0;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        myTextView = (TextView)this.findViewById(R.id.text_view);
        myButton = (Button)this.findViewById(R.id.post);
        myButton.setOnClickListener(this);
        //初始化HandlerThread
        myThread = new HandlerThread("handlerThread_test");
        //啟動HandlerThread
        myThread.start();
        //初始化HandlerThrand的Handler對象
        myThreadHandler = new Handler(myThread.getLooper(), new Handler.Callback() {
            @Override
            //實現消息處理。
            public boolean handleMessage(Message msg) {
                int what =msg.what;
                Log.e("Test", "Click Button = " + what);
                return false;
            }
        });
    }

    @Override
    public void onClick(View v) {
        count++;
        //通過Handler給HandlerThread線程發送消息
        myThreadHandler.sendEmptyMessage(count);
        //通過Handler給HandlerThreand發送要執行的任務。
        myThreadHandler.post(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Log.e("Test", "Hello world1");
            }
        });
        myThreadHandler.post(new Runnable() {
            @Override
            public void run() {
                Log.e("Test", "Hello world2");
            }
        });
    }
}

從這個例子不難看出HandlerThread實際上是一個Thread，而這個Thread是負責處理Handler派發的消息和任務。此外值得注意有三點：

第一，只有一個線程來處理各種任務。

第一，執行的任務時有序的。也就是說順序可以被控制。

第二，可以執行各種自定義的任務。

最后關於HandlerThread的退出：myThread.quit();

HandlerThread與SyncTask相比較，缺少執行過程的反饋。但是執行任務的多樣性超過SyncTask。當然了都只啟動了一個線程。

HandlerThread與Handler-Thread模式比較，也是缺少執行反饋。但是執行多任務時，HandlerThread卻只需要一個線程。

 

所有的Handler就到這里了。也不經意間把SyncTask拿出來溜了一下。其他兩篇

Handler 原理分析和使用（一）

Handler 原理分析和使用（二）

Handler完了。