HandlerThread 源码解析

HandlerThread 是什么？

系统对 HandlerThread 的解释是这么一段话：

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.

从上面这段话可以看出，HandlerThread 是一个是可以创建带有looper新线程的类，而这个 looper 是用来创建 handler 类的。需要注意的是HandlerThread 在创建后必须调用他的 start() 方法。这就是 HandlerThread 释义了。至于怎么用 HandlerLooper这里就不做介绍了

源码解析

HandlerThread的源码不多只有150行，首先我们看他的构造函数

public class HandlerThread extends Thread {
//线程优先级
int mPriority;
//线程id
int mTid = -1;
//当前线程持有的Looper对象
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;
}

/**
 * Call back method that can be explicitly overridden if needed to execute some
 * setup before Looper loops.
 */
protected void onLooperPrepared() {
}

可以看到有两个构造函数方法，一个参数 name 值的是线程名称，一个参数 priority指的是线程优先级。
onLooperPrepared() 该方法是留给我们自己实现的。是在Looper创建完成后调用的。

在前面介绍HandlerThread时介绍了必须要调用 start()方法，所以当调用这个方法相当于启动了线程，也就是run 方法将被调用。所以我们来看看 HandlerThread 重写的 run方法

    @Override
    public void run() {
        //获取线程id
        mTid = Process.myTid();
        //启用Looper,当Looper被创建后将绑定当前线程
        Looper.prepare();
        synchronized (this) {
            //创建 Looper
            mLooper = Looper.myLooper();
            //唤醒等待线程
            notifyAll();
        }
        //设置线程优先级
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        //让Looper开始工作，从消息队列里取消息，处理消息
        Looper.loop();
        mTid = -1;
    }

可以看到在 run 方法里完成了将Looper绑定到当前线程， Looper 的创建，唤醒等待的线程，设置线程优先级，调用onLooperPrepared() 方法，让Looper 开始工作取消息处理消息。这里或许你有疑问，为什么要调用 notifyAll() 方法来唤醒等待的线程，看下面代码就可以揭晓答案：

    public Looper getLooper() {
        //判断当前线程是否启动，即是否调用了start()方法
        if (!isAlive()) {
            return null;
        }

        // If the thread has been started, wait until the looper has been created.
        synchronized (this) {
            //判断Looper是否创建完成，如果没有则一直调用 wait() 让线程等待唤醒
            while (isAlive() && mLooper == null) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
        }
        return mLooper;
    }

这里当我们调用 getLooper 时，若 Looper还没有创建完成，则会调用 wait() 让线程一直处于等待唤醒状态，知道Looper创建完成并通过notifyAll()方法唤醒等待的线程，最后返回 Looper对象。之所以有等待唤醒机制，是因为Looper 在子线程里创建而 getLooper 是在主线程里调用，这里就会涉及到一个线程同步的问题，我们无法确保在调用 getLooper 时Looper 已经被创建好。所以 HanlderLooper 这里采用了等待唤醒来解决线程同步问题。

最后我们再看看剩下的两个方法：

    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;
    }

从源码可以看出当我们调用 quit方法时实际调用了 looper.quit(),而最终执行的是 MessageQueue的 removeAllMessagesLocked 方法，该方法主要是把MessageQueue 的消息池中的所有消息全部清空，无论是延迟消息还是非延迟消息。
而quitSafely() 则调用的是looper.quitSafely()（需要注意的是looper.quitSafely() 方法是在 API 18 以后添加的）。而looper.quitSafely()最终调用的是 MessageQueue的 removeAllFutureMessagesLocked 方法，该方法只会清空MessageQueue 消息池中所有的延迟消息，并将所有的非延迟消息派发出去让 Handler 去处理完成后才停止 Looper 循环