HandleThread面试详解

在Android中，如果我们执行比较耗时的操作一般都是开启子线程来执行。但频繁的创建和销毁线程是很消耗系统资源的。解决办法就是使用线程池或着HandleThread。

本文主要讲解：
1.什么是HandleThread
2.HandlerThread的使用场景以及怎样使用HandlerThread？
3.HandlerThread源码分析

---

1.什么是HandleThread？
HandlerThread是Google帮我们封装好的框架，可以用来执行多个耗时操作，而不需要多次开启线程。其内部实现为：Handle + Thread + Loop。

HandleThread本身就是一个线程，继承了Thread。与普通线程不同的地方就是内部有loop。因为我们如果想在子线程中使用Handle，就必须在子线程中创建loop对象。 使用Looper.prepare();来创建当前线程的loop，接着使用 Looper.loop();来开启循环，这样我们才能在线程中创建Handle。而Handle的内部就是这样实现的。

---

2.怎样使用HandlerThread？
怎样使用HandlerThread，步骤如下：
1.创建HandlerThread的实例对象

HandlerThread handlerThread = new HandlerThread("myHandlerThread");

该参数表示线程的名字。

2.启动我们创建的HandlerThread线程

handlerThread.start();

3.将我们的handlerThread与Handler绑定在一起。 还记得是怎样将Handler与线程对象绑定在一起的吗？其实很简单，就是将线程的looper与Handler绑定在一起，代码如下：

mThreadHandler = new Handler(mHandlerThread.getLooper()) {
    @Override
    public void handleMessage(Message msg) {
        checkForUpdate();
        if(isUpdate){
            mThreadHandler.sendEmptyMessage(MSG_UPDATE_INFO);
        }
    }
};

注意必须按照以上三个步骤来。

---

3.HandlerThread源码分析

public class HandlerThread extends Thread {
    int mPriority;
    int mTid = -1;
    Looper mLooper;

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

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

    /**
     * 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();
        //持有锁机制来获得当前线程的Looper对象
        synchronized (this) {
            mLooper = Looper.myLooper();
            //发出通知，当前线程已经创建mLooper对象成功，这里主要是通知getLooper方法中的wait
            notifyAll();
        }
        //设置线程的优先级别
        Process.setThreadPriority(mPriority);
        //这里默认是空方法的实现，我们可以重写这个方法来做一些线程开始之前的准备，方便扩展
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }

    public Looper getLooper() {
        if (!isAlive()) {
            return null;
        }
        // 直到线程创建完Looper之后才能获得Looper对象，Looper未创建成功，阻塞
        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;
    }

    public boolean quitSafely() {
        Looper looper = getLooper();
        if (looper != null) {
            looper.quitSafely();
            return true;
        }
        return false;
    }

    /**
     * Returns the identifier of this thread. See Process.myTid().
     */
    public int getThreadId() {
        return mTid;
    }
}

首先我们看构造方法

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

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

有两个构造方法， name表示线程名称，priority表示线程的优先级。

主要我们来看下run（）方法：

 @Override
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        //持有锁机制来获得当前线程的Looper对象
        synchronized (this) {
            mLooper = Looper.myLooper();
            //发出通知，当前线程已经创建mLooper对象成功，这里主要是通知getLooper方法中的wait
            notifyAll();
        }
        //设置线程的优先级别
        Process.setThreadPriority(mPriority);
        //onLooperPrepared()这里默认是空方法的实现，
        //我们可以重写这个方法来做一些线程开始之前的准备，方便扩展
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }

可以看到， Looper.prepare();来初始化一个Looper。

上述使用HandlerThread的时候必须调用start()方法，接着才可以将我们的HandlerThread和我们的handler绑定在一起吗?其实原因就是我们是在run()方法才开始初始化我们的looper，而我们调用HandlerThread的start()方法的时候，线程会交给虚拟机调度，由虚拟机自动调用run方法。

同时在获得mLooper对象（ mLooper = Looper.myLooper();）的时候存在一个同步的问题，只有当线程创建成功并且Looper对象也创建成功之后才能获得mLooper的值。这里等待方法wait和run方法中的notifyAll方法共同完成同步问题。
最后，我们使用 Looper.loop();来开启循环，这样我们就使用该线程的Looper了。

---

最后总结一下HandleThread的特点：
1.HandleThread本质上是一个线程类，继承了Thread。
2.HandleThread有自己的Looper对象，可以进行Looper循环。
3.通过将HandleThread的Loop对象传递给Handle对象，可以在HandleMessage（）中执行异步任务。
4.与线程池并发不同，HandleThread内部只有一个线程，是一个串行的队列。
5.优点是不会堵塞，减少了对性能的消耗。缺点是不能同时进行多任务处理，需等待处理，效率较低。