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完了。