HandlerThread
在理解了Handler的原理之后，我们知道在一个子线程中创建一个Handler不能缺少了Looper.prepare()和Looper.loop()两个方法，具体的原因这里不再赘述，不熟悉原理的可以先看下另一篇文章Handler的原理解析.
本篇文章主要是讲解HandlerThread的使用的。
首先HandlerThread是继承于Thread类的，所以本质上HandlerThread就是一个线程，接下来就详细的去看一看，这是怎样的一个线程？
首先，先看下它的构造函数：
public HandlerThread(String name) {
super(name);
mPriority = Process.THREAD_PRIORITY_DEFAULT;
}
public HandlerThread(String name, int priority) {
super(name);
mPriority = priority;
}
//很简单，构造函数里只是设置了该Thread的名称和优先级。
既然是线程，那么最重要的当然是run方法来，看完了run方法，相信你也就明白HandlerThread的用途了！
@Override
public void run() {
mTid = Process.myTid();
Looper.prepare();
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop();
mTid = -1;
}
怎么样，这是不是和我们之前在子线程中创建Handler一样，首先是Looper.prepare(),接着是new Handler(), 最后是Looper.loop()。等等，这里并没有创建Handler啊！别急，我们先一步一步地看看run方法再说为什么没有创建Handler。
- 首先呢是调用了Looper.prepaer()，该方法为我们的线程创建了一个唯一的Looper和MessageQueue对象，具体的创建过程看另一篇文章Handler的原理解析
- 接下来有一个同步锁的代码块，里面获取到了创建好的Looper对象将其赋值给当前的mLooper，然后唤醒了锁。注意这里有一个唤醒线程的操作，既然有唤醒锁的操作，那么必定有有个地方使线程处于了阻塞的状态，我们看下出现阻塞的地方。
public Looper getLooper() {
if (!isAlive()) {
return null;
}
// If the thread has been started, wait until the looper has been created.
synchronized (this) {
while (isAlive() && mLooper == null) {
try {
wait();
} catch (InterruptedException e) {
}
}
}
return mLooper;
}
通过查找发现到一个getLooper()的方法，该方法返回了当前线程的mLooper对象，还记得Looper是在哪里进行赋值的吗？在线程的run方法里，所以当线程启动之后才能创建Looper并赋值给mLooper，这里的阻塞就是为了等待Looper的创建成功。同时该方法是用Public修饰的，说明该方法是提供外部调用的，Looper创建成功提供给外部使用。
- 接着我们回到run方法，Looper和MessageQueue已经创建成功了，接下来就是启动Looper循环了(即Looper.loop())，别忘了只有Looper循环启动后我们才能时刻观察着MessageQueue，只要有Message了才能立马将Message取出来进行分发处理。
- 在Looper.loop()之前还调用了一个onLooperPrepared()方法，这个方法是干嘛的呢？ 看代码可知，只是一个空方法，在使用HandlerThread时重写该方法，方便在Looper轮询消息之前做一些初始化的操作。
/**
* Call back method that can be explicitly overridden if needed to execute some
* setup before Looper loops.
*/
protected void onLooperPrepared() {
}
最后在对象销毁前，调用下面的方法退出Looper循环
public boolean quit() {
Looper looper = getLooper();
if (looper != null) {
looper.quit();
return true;
}
return false;
}
public boolean quitSafely() {
Looper looper = getLooper();
if (looper != null) {
looper.quitSafely();
return true;
}
return false;
}
quit方法实际是调用MessagQueue的removeAllMessagesLocked，移除所有延迟和非延迟的消息，
quitSafely方法调用的是removeAllFutureMessagesLocked方法，该方法只清除延迟的消息，非延迟的消息
还是会进行分发处理。
HandlerThread分析完啦，是不是有点蒙，自始至终都没有出现Handler，HandlerThread要怎么用呢？
下面我们就通过一个Demo来说明下HandlerThread是怎么用的？
private WorkHandler mHandler;
private HandlerThread mHandlerThread;
/*Handler存在一个构造函数，传入一个Looper对象，Handler的handleMessage获取的是Looper的MessageQueue中的Message
因此，handleMessage的调用与Looper对象同属于一个线程，这里我们在构造时传入HandlerThread的Looper对象，
handleMessage运行于HandlerThread线程（也就是一个子线程），所以Handler虽然是在住线程创建，但是它的
handleMessage接收到消息是在HandlerThread线程，执行下代码可以看到打印出如下log：
D/HandlerThreadDemo: HandlerThread/Demo thread receiver the message from thread: main
log也说明，message由主线程传递到了HandlerThread中。
*/
private class WorkHandler extends Handler {
WorkHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
String str = (String) msg.obj;
Log.d(TAG, Thread.currentThread().getName() + " thread receiver the message from thread: " + msg.obj);
}
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_handlerthread_demo);
mHandlerThread = new HandlerThread("HandlerThread/Demo");
mHandlerThread.start();
mHandler = new WorkHandler(mHandlerThread.getLooper());
Message msg = mHandler.obtainMessage();
msg.obj = Thread.currentThread().getName();
mHandler.sendMessage(msg);
}
总结：
- HandlerThread继承于Thread，本质上也是一个线程。
- HandlerThread的run方法为本线程创建提供了Looper和MessageQueue对象，并开启了Looper轮询消息。
- 通过在需要发送Message的线程中创建Handler，为Handler提供来自HandlerThread的Looper对象。Handler则能
将消息发送到HandlerThread上去进行处理。
注意：这里Handler不仅仅能在主线程创建，在子线程同样能够创建，只需要将对应的Looper提供给Handler即可，所以HandlerThread
不仅适用于和主线程通信，同样适用于和其他子线程通信。 - 最后需要注意的是在我们不需要这个looper线程的时候需要手动停止掉，即调用quit()或者quitSafely()。
- 最后补充一个在实际开发过程中使用到HandlerThread的场景：
存在多个耗时的任务需要放到开启子线程依次去处理（串行处理任务）,首先，HandlerThread是一个子线程，
适合处理耗时的任务，其次，Handler分发消息是通过MessageQueue顶部的Message不断的通过Message的next依次取出
Message，符合任务的按顺序串行处理的要求，所以使用HandlerThread就能完美的解决此需求。
