前言
这个东西看着很高端的感觉，刚开始没明白这是用来干啥用的，他的源码也很简单，简单到都想不出来他的场景，后面看到以博客毛瑟顿开，HandlerThread的特点，大概就是说，它用子线程的Looper，使我们的消息在子线程中处理，通常我们都是绑定了主线程的 MessageQueue，一定程度上加大了主线程消息处理的负担。在子线程中处理消息，自然也不能处理消息，可以处理一些后台的任务，但是他是串行处理，所以使用时要注意了。
HandlerThread 是什么东西？
先看名字，有 Handler，又有 Thread，聪明的你一想就知道了，他是一个 Thread，既然是Thread，那就有 Thread 的特性，比如你可以 start 启动线程。回到正题，其实他就是一个帮你初始化了一个子线程 Looper 的 Thread，那他的使用就是获取这个Looper，绑定到Handler，就可以使处理消息的代码执行在子线程。
前世今生
继承自Thread，使用时可以调用 .start()，注意 run 和 start 的区别
public class HandlerThread extends Thread {}
源码分析
属性
-
mPriority是线程的优先级，默认为Process.THREAD_PRIORITY_DEFAULT，注意，安卓的线程优先级比 Java 的影响要大，虽然 JVM 是抢占式地优先级调度，但其实并不能保证这个语义，开发者不应该完全依赖这个。 -
mTid是线程 id -
mLooperLooper对象 -
Handler对象
int mPriority;
int mTid = -1;
Looper mLooper;
private @Nullable Handler mHandler;
public HandlerThread(String name) {
super(name);
mPriority = Process.THREAD_PRIORITY_DEFAULT;
}
函数
run 函数很简单，先 Looper.prepare()，给当前线程的初始化一个 Looper 对象，需要注意的是，这个方法不能在当前线程多次调用，会抛出 new RuntimeException("Only one Looper may be created per thread"); 异常，不明白的可以去看这一篇Handler 源码大白话。有一个 onLooperPrepared() 方法你可以去重写，主要是 Looper.loop() 调用前的一些准备操作
/**
* Call back method that can be explicitly overridden if needed to execute some
* setup before Looper loops.
*/
protected void onLooperPrepared() {
}
@Override
public void run() {
mTid = Process.myTid();
Looper.prepare();
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop();
mTid = -1;
}
获取Looper，代码简单易懂，需要注意，如果线程还活着，如果 looper 为空，那么则阻塞等待初始化，这里使用了 synchronized 以及 wait notify 机制，有时间得好好研究一下这个机制，总感觉掌握的还不够
/**
* This method returns the Looper associated with this thread. If this thread not been started
* or for any reason isAlive() returns false, this method will return null. If this thread
* has been started, this method will block until the looper has been initialized.
* @return The looper.
*/
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;
}
关闭Looper，或者使用quitSafely() 这是一个安全的方法
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;
}
一个简单的例子（纯手写,不保证对）
@MainThread
private HandlerThread mHT = new HandlerThread("WorkerHandler");
private Handler mH;
@Override
public void onCreate(Bundle savedInstanceState) {
mHT.start();
mH = new Handler(mHT.getLooper()) {
@Override
public void handleMessage(Message msg) {
Log.v("mhT", "I received the msg: " + msg + " from" + Thread.currentThread());
}
};
}
@Override
public void onDestroy() {
mHT.quitSafely();
}
小结
如果我们的消息不需要更新UI，可以考虑使用这种子线程消息处理模式。当然，你也可以传入主线程的 Looper，但这违背了 HandlerThread 初衷，即在一个独立的线程中处理消息～
欢迎讨论，如果有了新的理解，会不断更新～
