初识HandlerThread

在Android中，Handler常常用来在子线程中更新View。示例代码如下：

public class MainActivity extends ActionBarActivity {

    private Handler handler1=new Handler(){
        @Override
        public void handleMessage(Message msg){
            //to do sth
        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        new Thread(new Runnable(){
            @Override
            public void run() {
                Message msg=Message.obtain();
                msg.what=1;
                Bundle bundle = new Bundle();  
                bundle.putString("info", "info");  
                msg.setData(bundle);  
                handler1.sendMessage(msg);
            }
        }).start();
    }

}

但是，上述代码仅仅是Handler的一个常见的使用场景而已。之前做过一个项目，项目中有一个相册图片加载模块，在这个模块中，我建立了一个后台轮询线程mPollingThread并在mPollingThread的run方法中初始化了mPollingThreadHandler,每当我们在LruCache中没有找到这次要加载的图片时，就新建一个任务(其实就是一个Runnable对象)，并将任务添加到我们的任务队列中，之后会通过mPollingThreadHandler发送一个消息给后台轮询线程，后台轮询线程收到消息后会从任务队列中取出一个任务执行，核心代码如下：

package com.example.myimageloader;

import java.util.concurrent.Semaphore;

import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.widget.ImageView;

public class ImageLoader {

    private Thread mPoolingThread; //后台轮询线程
    private Handler mPoolingThreadHandler; //后台轮询线程对应的Handler
    private Semaphore mSemaphorePoolingThreadHandler=new Semaphore(0);
    private ImageLoader(){
        mPoolingThread=new Thread(){
            @Override
            public void run(){
                Looper.prepare();
                mPoolingThreadHandler=new Handler(){
                    @Override
                    public void handleMessage(Message msg){
                        //从任务队列中取出一个任务，并交给线程池执行
                        //......
                    }
                };
                //mPoolingThreadHandler初始化完成，释放一个信号量
                mSemaphorePoolingThreadHandler.release();
                Looper.loop();
            }
        };
        mPoolingThread.start();
    }
    public void loadImage(final String path,final ImageView imageView){
        //没有在LruCache中找到相应的图片
        //创建任务并加入到任务队列中
        addTask(new Runnable(){
            @Override
            public void run() {
                //.....
            }
            
        });
    }
    
    private synchronized void addTask(Runnable runnable){
        //将任务加入到任务队列中
        //.......
        //发送消息给后台轮询线程
        if(mPoolingThreadHandler==null){
            try {
                mSemaphorePoolingThreadHandler.acquire();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        mPoolingThreadHandler.sendEmptyMessage(0x110);
    }
}

其实，上面核心代码的主要目的是让我们的mPoolingThreadHandler的handleMessage方法能够运行在子线程中，但是，mPoolingThreadHandler的创建是在后台轮询线程的run方法中，mPoolingThreadHandler的使用是在主线程的loadImage方法中，所以很有可能mPoolingThreadHandler在主线程中使用的时候处于尚未创建完成的状态，导致程序报空指针异常。上述代码使用了Semaphore来解决这个问题，简单地讲，就是我们在主线程中使用mPoolingThreadHandler的时候，如果发现mPoolingThreadHandler为空，会去请求一个信号量，我们在后台轮询线程的run方法中，一旦mPoolingThreadHandler创建完成，就释放一个信号量，以此来解决我们主线程和后台轮询线程之间的同步问题。

不知道大家有没有这样的感觉，上面的程序，写起来好麻烦。。。
那有没有更加简化的写法呢？答案是有的！有的！！有的！！！重要的事情说三遍！
这就要用到我们今天即将介绍的HandlerThread了。
先来看一下HandlerThread在Google官方文档上的介绍：

官方文档讲得很清楚，HandlerThread是一个用于启动一个拥有Looper的新线程的类，该Looper能够被用来创建Handler，特别注意的是，start()方法仍然必须被调用。
我们再去看HandlerThread的成员方法，发现有这样一个方法：

该方法会返回一个和该线程相关的Looper对象。如果该线程已经被启动，该方法会阻塞直至Looper对象被初始化完成。

我们再去看一下Handler的构造方法：

可以看到，Handler有一个构造方法是以Looper 作为参数的。

之前在Android异步消息处理机制深度解析这篇文章中有过这样的总结：如果创建Handler时用的是主线程的Looper,则相应的handleMessage方法会运行在主线程中，如果创建Handler时用的是子线程的Looper,则相应的handleMessage方法会运行在子线程中。

好了，知道了这些，现在我们可以去重写相册图片加载模块的代码了，重写后的代码如下：

public class ImageLoader {
     private HandlerThread mPoolingThread; //后台轮询线程
     private Handler mPoolingThreadHandler; //后台轮询线程对应的Handler
     private ImageLoader(){
         mPoolingThread=new HandlerThread("Pooling Thread");
         mPoolingThread.start();
         mPoolingThreadHandler=new Handler(mPoolingThread.getLooper()){
             @Override
             public void handleMessage(Message message){
                 //该方法运行在子线程中
                 //从任务队列中取出一个任务，并交给线程池执行
                 //......
             }
         };
     }
     public void loadImage(final String path,final ImageView imageView){
            //没有在LruCache中找到相应的图片
            //创建任务并加入到任务队列中
            addTask(new Runnable(){
                @Override
                public void run() {
                    //.....
                }
                
            });
      }
     
     private synchronized void addTask(Runnable runnable){
            //将任务加入到任务队列中
            //.......
            //发送消息给后台轮询线程
            mPoolingThreadHandler.sendEmptyMessage(0x110);
     }
}

虽然我们是在主线程初始化mPoolingThreadHandler，但由于初始化的时候用的是子线程mPoolingThread的Looper，所以mPoolingThreadHandler的handleMessage方法是运行在子线程中的，效果和之前的ImageLoader代码是一模一样的。

好了，今天对HandlerThread的介绍到这里就要结束了，相信大家对HandlerThread已经有了一个大体的了解了，下一篇博客将对HandlerThread的源码进行深入剖析，让大家对HandlerThread有一个全面而透彻的理解，一起期待吧！

参考：http://blog.csdn.net/lmj623565791/article/details/47079737