Android HandlerThread简介

Android应用中的消息循环由Looper和Handler配合完成，Looper类用于封装消息循环，Handler类封装了消息投递和消息处理等功能，系统默认情况下只有主线程（即UI线程）绑定Looper对象，因此在主线程中可以直接创建Handler的实例，但是在子线程中就不能直接new出Handler的实例了，因为子线程默认并没有Looper对象，此时会抛出RuntimeException异常。如果需要在子线程中使用Handler类，首先需要创建Looper类实例，这时可以通过Looper.prepare()和Looper.loop()函数来实现。

Handler与谁相关联不是看声明在什么地方，是看与哪个线程的Looper挂钩。默认是主线程的Looper，因为主线程中默认就有了Looper、消息循环队列。

不管是主线程(一般是我们的UI线程)还是子线程，只要有Looper的线程，别的线程就可以向这个线程的消息队列中发送消息和计划任务，然后做相应的处理。

Android为我们提供了一个HandlerThread类，该类继承Thread类，类中有个MessageQueue消息队列；与普通Thread的差别就在于，它有个Looper成员变量。这个Looper其实就是对消息队列以及队列处理逻辑的封装，简单说就是消息队列+消息循环。使用Looper.prepare()和Looper.loop()两个函数创建Looper对象，而且使用wait/notifyAll解决了多线程中子线程1获取子线程2的Looper对象为空的问题。HandlerThread源码解释:

public class HandlerThread extends Thread{
//线程的优先级
private int mPriority;
//线程的id
private int mTid=-1;
private Looper mLooper;
public HandlerThread(String name){
super(name);
//设置优先级为默认线程
mPriority=Process.THREAD_PRIORITY_DEFAULT;
}

public HandlerThread(String name，int priority){
super(name);
mPriority=priority;
}

//这个如果有需要的话可以继承重写，例如可以在里面声明一个Handler关联此线程。
protected void onLooperPrepared(){
public void run(){
//得到当前线程的id
mTid=Process.myTid;
//通过此方法就在此线程中创建了Looper 对象。这就是为什么我们要在调用线程的start()方法后
//才能得到Looper 对象即当调用Looper.myLooper()时不为Null。
Looper.prepare();
//同步代码块，意思就是当获得mLooper对象后，唤醒所有线程。
synchronized(this){
mLooper=Looper.myLooper();
notifyAll();
}

//设置线程的优先级
Process.setThreadPriority(mPriority);
//调用上面的方法（需要用户重写）
onLooperPrepared();
//建立了消息循环
Looper.loop();
mTid=-1;
}

public Looper getLooper(){
//线程死了，那就只有NULL了。
if(!isAlive()){
return null;
}
//同步代码块，正好和上面的形成对应，就是说只要线程活着并且我的looper为NULL，那么我就让你一直等。。。
synchronized(this){
while(isAlive()&&mLooper==null){
try{
wait();
}catch(InterruptedException e){}
}
}
return mLooper;
}
public boolean quit(){
Looper looper =getLooper();
if(looper!=null){
//退出消息循环
looper.quit();
return true;
}
return false;
}
//返回线程ID
public int getThreadId(){
return mTid;
}
}

结合Handler使用:

Handler handler = new Handler(Looper, Callback);

// Looper--> HandlerThread.getLooper();传入Callback参数，使自定义的HandlerThread的handlerMessage替换掉Handler原生的handlerMessage;

Android中的Looper类，是用来封装消息循环和消息队列的一个类，用于在android线程中进行消息处理。handler其实可以看做是一个工具类，用来向消息队列中插入消息的。

(1) Looper类用来为一个线程开启一个消息循环。
默认情况下android中新诞生的线程是没有开启消息循环的。（主线程除外，主线程系统会自动为其创建Looper对象，开启消息循环。）
Looper对象通过MessageQueue来存放消息和事件。一个线程只能有一个Looper，对应一个MessageQueue。

(2) 通常是通过Handler对象来与Looper进行交互的。Handler可看做是Looper的一个接口，用来向指定的Looper发送消息及定义处理方法。
默认情况下Handler会与其被定义时所在线程的Looper绑定，比如，Handler在主线程中定义，那么它是与主线程的Looper绑定。
mainHandler = new Handler() 等价于new Handler（Looper.myLooper()）.
Looper.myLooper()：获取当前进程的looper对象，类似的 Looper.getMainLooper() 用于获取主线程的Looper对象。

(3) 在非主线程中直接new Handler() 会报如下的错误:
E/AndroidRuntime( 6173): Uncaught handler: thread Thread-8 exiting due to uncaught exception
E/AndroidRuntime( 6173): java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()
原因是非主线程中默认没有创建Looper对象，需要先调用Looper.prepare()启用Looper。

(4) Looper.loop(); 让Looper开始工作，从消息队列里取消息，处理消息。

注意：写在Looper.loop()之后的代码不会被执行，这个函数内部应该是一个循环，当调用mHandler.getLooper().quit()后，loop才会中止，其后的代码才能得以运行。

(5) 基于以上知识，可实现主线程给子线程（非主线程）发送消息。

把下面例子中的mHandler声明成类成员，在主线程通过mHandler发送消息即可。

Android官方文档中Looper的介绍：
Class used to run a message loop for a thread. Threads by default do not have a message loop associated with them; to create one, call prepare() in the thread that is to run the loop, and then loop() to have it process messages until the loop is stopped.

Most interaction with a message loop is through the Handler class.

This is a typical example of the implementation of a Looper thread, using the separation of prepare() and loop() to create an initial Handler to communicate with the Looper.

class LooperThread extends Thread {
public Handler mHandler;
public void run() {
Looper.prepare();
mHandler = new Handler() {
public void handleMessage(Message msg) {
// process incoming messages here
}
};
Looper.loop();
}
}