Android源码解析Handler系列第（五）篇 ---HandlerThread你用过吗？

Handler这个系列总共有5篇，这是最后一篇了。前面三篇博客，我们从源码的层面将Handler消息机制梳理了一遍，第四篇站在源码层之上回顾以前学习时候困惑的一些问题。OK，开始飙车了，学习HandlerThread，如果你还没有看过我之前的四篇文章，建议去了解，只有深入了解的东西，才能被记住。

Android源码解析Handler系列第（一）篇 — Message全局池

Android源码解析Handler系列第（二）篇 — ThreadLocal详解

Android源码解析Handler系列第（三）篇 — 深入了解Android的消息机制

Android源码解析Handler系列第（四）篇 — 打破Handler那些困惑事儿

通过前面的学习，我们知道Android整个系统都是通过消息来驱动的，在主线程中默认给我们创建了Looper，即是我们常说的MainLooper，MainLooper是个循环器，有合适的消息立刻取出来交给Handler去处理（一个一个的取出来，一个一个的处理），没有消息处于等待状态。如果有大量的消息向MainLooper涌来，主线程中的MainLooper的工作量会不会很大呢？如果主线程压力过大，界面不流畅咋办？性能是大个问题！！！为了解这种问题,此刻你会想，我们自己构建一个循环线程Looper/Thread,当有耗时任务投放到该循环线程中时，线程执行耗时任务，执行完之后循环线程处于等待状态，直到下一个新的耗时任务被投放进来,这样不就分担了主线程的压力了嘛！！！其实Android SDK中有一个循环线程的框架—HandlerThread。先来看看怎么使用HandlerThread。

1、创建HandlerThread

mWorkHandler = new HandlerThread("workHandleThread");
mWorkHandler.start();

2、获取获取HandlerThread的Looper

Looper looper = mWorkHandler.getLooper();

3、 创建Handler，通过Looper初始化，mCallback中处理耗时任务

final Handler  mSubHandler = new Handler(looper,mCallback);

4、投放异步耗时任务到HandlerThread中

mSubHandler.sendEmptyMessage(0);

5、记得回收

@Override
protected void onDestroy() {
super.onDestroy();
mWorkHandler.quit();
}

完整的代码如下：

public class HomeActivity extends AppCompatActivity {

Handler.Callback  mCallback=new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
//该接口的实现就是处理异步耗时任务的，因此该方法执行在子线程中
Log.d("Callback",     Thread.currentThread().getName());
return false;
}
};

HandlerThread mWorkHandler;

@Override protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Button   btn= (Button) findViewById(R.id.btn);

Log.d("onCreate", Thread.currentThread().getName());

//1、创建HandlerThread
mWorkHandler = new HandlerThread("workHandlerThread");
mWorkHandler.start();

//2、获取获取HandlerThread的Looper
Looper looper = mWorkHandler.getLooper();

//3、 创建Handler，通过Looper初始化
final Handler  mSubHandler = new Handler(looper,mCallback);

//4、投放异步耗时任务到HandlerThread中

// mSubHandler.sendEmptyMessage(0);

btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mSubHandler.sendEmptyMessage(0);
}
});

}

@Override
protected void onDestroy() {
super.onDestroy();
if (mWorkHandler != null) {
mWorkHandler.quit();
}
}
}

注意上面Log的输出

12-08 19:49:25.010 25931-25931/com.zhangwan.www.viewstub D/onCreate: main
12-08 19:49:26.014 25931-30599/com.zhangwan.www.viewstub D/Callback: workHandlerThread

现在确定mCallback的handleMessage是在子线程中执行的。所以可以在这里面去做一些耗时的任务。

OK，基本的用法我们知道了，看看它的源码，首先看下它的构造和类定义。

/**
* Handy class for starting a new thread that has a looper. The looper can then be
* used to create handler classes. Note that start() must still be called.
*/
public class HandlerThread extends Thread {
int mPriority;
int mTid = -1;
Looper mLooper;

public HandlerThread(String name) {
super(name);
mPriority = Process.THREAD_PRIORITY_DEFAULT;
}

/**
* Constructs a HandlerThread.
* @param name
* @param priority The priority to run the thread at. The value supplied must be from
* {@link android.os.Process} and not from java.lang.Thread.
*/
public HandlerThread(String name, int priority) {
super(name);
mPriority = priority;
}
//.....代码省略
}

HandlerThread的父类是Thread，内部会有一个looper循环，并且可以设置优先级与线程的名字。优先级范围为-20到19，默认为0，优先级越高，获得的CPU资源更多，反之则越少。-20代表优先级最高，反之19最低。通过构造函数HandlerThread的实例mWorkHandler就被创建起来了。现在调用mWorkHandler.start()启动它。 线程的start就是执行HandlerThread的run方法。

@Override
public void run() {
//当前线程的id
mTid = Process.myTid();
//准备一个Looper
Looper.prepare();
//持有锁机制来获得当前线程的Looper对象
synchronized (this) {
//发出通知，当前线程已经创建mLooper对象成功，这里主要是通知getLooper方法中的wait
mLooper = Looper.myLooper();
notifyAll();
}

//设置线程的优先级
Process.setThreadPriority(mPriority);
onLooperPrepared();
//Looper循环开启
Looper.loop();
mTid = -1;
}

用了Looper.prepare和Looper.loop构建了一个循环线程，onLooperPrepared是一个空实现的方法，子类可以重写，做一些初始化的工作。

/**
* This method returns the Looper associated with this thread. If this thread not been started
* or for any reason is 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;
}

如果当前线程是存活的，在判断线程的成员变量mLooper是否为NULL,如果为NULL，说明当前线程已经创建成功，但是还没有来得及创建Looper对象，所以需要调用wait方法等待，当run方法中的notifyAll方法调用之后，通知当前线程的wait等待结束，跳出循环，返回mLooper对象。

当我们要退出时，有quit和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;
}

两种方式的不同点是，当我们调用Looper的quit方法时，实际上执行了MessageQueue中的removeAllMessagesLocked方法，该方法的作用是把MessageQueue消息池中所有的消息全部清空，无论是延迟消息（延迟消息是指通过sendMessageDelayed或通过postDelayed等方法发送的需要延迟执行的消息）还是非延迟消息。当我们调用Looper的quitSafely方法时，实际上执行了MessageQueue中的removeAllFutureMessagesLocked方法，通过名字就可以看出，该方法只会清空MessageQueue消息池中所有的延迟消息，并将消息池中所有的非延迟消息派发出去让Handler去处理，quitSafely相比于quit方法安全之处在于清空消息之前会派发所有的非延迟消息。需要注意的是Looper的quit方法从API Level 1就存在了，但是Looper的quitSafely方法从API Level 18才添加进来。

最后总结一下使用HandlerThread的好处；

HandlerThread将loop转到子线程中处理，说白了就是将分担MainLooper的工作量，降低了主线程的压力，使主界面更流畅。

HandlerThread拥有自己的消息队列，它不会干扰或阻塞UI线程。

参考链接：

http://blog.csdn.net/feiduclear_up/article/details/46840523

http://www.cnblogs.com/zhaoyanjun/p/6062880.html

Please accept mybest wishes for your happiness and success!