HandlerThread 是一个封装好的looper线程类。
从源码看看
public class HandlerThread extends Thread {
int mPriority; // 线程优先级
int mTid = -1; // 修改线程优先级、调度策略时用来做线程唯一标识
Looper mLooper; // 与线程关联的Looper
public HandlerThread(String name) {
super(name);
mPriority = Process.THREAD_PRIORITY_DEFAULT; // 设置默认优先级0
}
public HandlerThread(String name, int priority) {
super(name);
mPriority = priority; // 主动设置优先级
}
protected void onLooperPrepared() { //回调方法，looper开始前执行
}
@Override
public void run() {
mTid = Process.myTid();
Looper.prepare(); // 初始化一个Looper对象，然后存入到ThreadLocal中，将Looper和当前线成进行绑定，一一对应.
synchronized (this) { // 进入同步块
mLooper = Looper.myLooper(); //得到当前线程的looper对象
notifyAll();//通知其他线程
}
Process.setThreadPriority(mPriority); // 设置线程优先级
onLooperPrepared(); // 回调重写
Looper.loop(); // 一个死循环，不断从MessageQueue取出消息，如有消息就处理，没有就阻塞
mTid = -1; // 因为Looper.loop()是个死循环啊，执行到mTid = -1的时候，就是looper退出的时候
}
public Looper getLooper() {
if (!isAlive()) { // 如果线程不是在存活状态则直接返回null。
return null;
}
synchronized (this) {
while (isAlive() && mLooper == null) { // 进入同步块，当条件不满足时无限等待，
try { // 直到mLooper被设置成有效值了才退出等待
wait(); // run方法里的notifyAll就是用来唤醒这里的
} catch (InterruptedException e) { // 中断异常
}
}
}
return mLooper; // 最后返回mLooper
}
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;
}
void quit(boolean safe) {
if (!mQuitAllowed) {
throw new IllegalStateException("Main thread not allowed to quit.");
}
synchronized (this) {
if (mQuitting) {
return;
}
mQuitting = true;
if (safe) {
removeAllFutureMessagesLocked();
} else {
removeAllMessagesLocked();
}
// We can assume mPtr != 0 because mQuitting was previously false.
nativeWake(mPtr);
}
}
quit（）和 quitSafely()的区别：
removeAllMessagesLocked（）是把MessageQueue消息池中所有的消息全部清空，无论延迟与否
removeAllFutureMessagesLocked（）是只清空延迟消息，非延迟消息派发出去让Handler去处理。
异步handler的创建方式
Thread newThread = new Thread(new Runnable()
{
@Override
public void run() {
Looper.prepare();
Looper.loop();
}
});
newThread.start();
Handler handler = new Handler(newThread.getLooper());
当执行到Handler handler = new Handler(newThread.getLooper());的时候，newThread的looper可能还没有创建好，会有线程同步的
问题。
总结：
1.不管调用哪个，Looper就不再接收新的消息，再通过Handler调用sendMessage发消息都只会返回false，Looper的quit方法从API Level 1就存在了，但是Looper的quitSafely方法从API Level 18才添加进来
2.HandlerThread本质是一个Thread，区别在于他在run（）之后创建了一个含有消息队列的Looper，这样我们在子线程中创建Handler时候只需指定使用HandlerThread中的Looper，不用再调用Looper.prepare(),looper.loop()，并且做了同步的处理，简化了操作。
3.另外Handler与Activity在同一个线程中，不能做耗时操作。HandlerThread是新的线程，可做耗时操作
举例：
public class MainActivity extends Activity {
private Handler handlerthread;
private HandlerThread thread;
//创建主线程中的handler
private Handler handler = new Handler() {
public void handleMessage(android.os.Message msg) {
Message message = new Message();
handlerthread.sendMessageDelayed(message, 1000);
Log.d("wuc", "主线程");
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Button bt_test = (Button)findViewById(R.id.bt_test);
bt_test.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
handlerthread.sendEmptyMessage(1);
}
});
thread = new HandlerThread("threadHandler");
thread.start();
handlerthread = new Handler(thread.getLooper()){
@Override
public void handleMessage(Message msg) {
Message message = new Message();
//handler每隔1秒向主线程发送一次消息。
Log.d("wuc", "子线程");
handler.sendMessageDelayed(message, 1000);
}
};
}
}
04-26 16:49:26.822 7349-7385/com.example.lyf.androidtext D/wuc: 子线程
04-26 16:49:27.822 7349-7349/com.example.lyf.androidtext D/wuc: 主线程
04-26 16:49:28.823 7349-7385/com.example.lyf.androidtext D/wuc: 子线程
04-26 16:49:29.826 7349-7349/com.example.lyf.androidtext D/wuc: 主线程
04-26 16:49:30.826 7349-7385/com.example.lyf.androidtext D/wuc: 子线程
04-26 16:49:31.827 7349-7349/com.example.lyf.androidtext D/wuc: 主线程
04-26 16:49:32.828 7349-7385/com.example.lyf.androidtext D/wuc: 子线程
