HandlerThread源码分析与应用

HandlerThread是继承于Thread类的，所以本质上HandlerThread就是一个线程。

源码分析

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

在构造函数中设置Thread的名称和优先级。

 @Override
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }

run方法中调用了Looper.prepare()，为我们的线程创建了一个唯一的Looper和MessageQueue对象。下面有一个同步锁的代码块，里面获取到了创建好的Looper对象将其赋值给当前的mLooper，然后唤醒了锁。注意这里有一个唤醒线程的操作，既然有唤醒锁的操作，那么必定有有个地方使线程处于了阻塞的状态：

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

在中getLooper()的方法，返回了当前线程的mLooper对象，Looper的赋值在线程的run方法里，所以当线程启动之后才能创建Looper并赋值给mLooper，这里的阻塞就是为了等待Looper的创建成功。同时该方法是用Public修饰的，说明该方法是提供外部调用的，Looper创建成功提供给外部使用。

然后回到run方法，Looper和MessageQueue已经创建成功了，接下来就是启动Looper循环了(即Looper.loop())，循环启动后时刻观察着MessageQueue，只要有Message了立刻将Message取出来进行分发处理。

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

在Looper.loop()之前还调用了一个onLooperPrepared()方法只是一个空方法，在使用HandlerThread时重写该方法，方便在Looper轮询消息之前做一些初始化的操作。

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方法实际是调用MessagQueue的removeAllMessagesLocked，移除所有延迟和非延迟的消息，quitSafely方法调用的是removeAllFutureMessagesLocked方法，该方法只清除延迟的消息，非延迟的消息
还是会进行分发处理。

应用

private WorkHandler mHandler;
    private HandlerThread mHandlerThread;
    /*Handler存在一个构造函数，传入一个Looper对象，Handler的handleMessage获取的是Looper的MessageQueue中的Message
      因此，handleMessage的调用与Looper对象同属于一个线程，这里我们在构造时传入HandlerThread的Looper对象，
      handleMessage运行于HandlerThread线程（也就是一个子线程），所以Handler虽然是在住线程创建，但是它的
      handleMessage接收到消息是在HandlerThread线程，执行下代码可以看到打印出如下log：
      D/HandlerThreadDemo: HandlerThread/Demo thread receiver the message from thread: main
      log也说明，message由主线程传递到了HandlerThread中。
    */
    private class WorkHandler extends Handler {
        WorkHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            String str = (String) msg.obj;
            Log.d(TAG, Thread.currentThread().getName() + " thread receiver the message from thread: " + msg.obj);
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_handlerthread_demo);
        mHandlerThread = new HandlerThread("HandlerThread/Demo");
        mHandlerThread.start();
        mHandler = new WorkHandler(mHandlerThread.getLooper());
        Message msg = mHandler.obtainMessage();
        msg.obj = Thread.currentThread().getName();
        mHandler.sendMessage(msg);
        
    }

总结：

1. HandlerThread继承于Thread，本质上也是一个线程。
2. HandlerThread的run方法为本线程创建提供了Looper和MessageQueue对象，并开启了Looper轮询消息。
3. 通过在需要发送Message的线程中创建Handler，为Handler提供来自HandlerThread的Looper对象。Handler则能
   将消息发送到HandlerThread上去进行处理。
   注意：这里Handler不仅仅能在主线程创建，在子线程同样能够创建，只需要将对应的Looper提供给Handler即可，所以HandlerThread不仅适用于和主线程通信，同样适用于和其他子线程通信。
4. 在不需要looper线程的时候需要手动停止掉，即调用quit()或者quitSafely()。
5. 最后补充一个在实际开发过程中使用到HandlerThread的场景：
   存在多个耗时的任务需要放到开启子线程依次去处理（串行处理任务）,首先，HandlerThread是一个子线程，
   适合处理耗时的任务，其次，Handler分发消息是通过MessageQueue顶部的Message不断的通过Message的next依次取出
   Message，符合任务的按顺序串行处理的要求，所以使用HandlerThread就能完美的解决此需求。

参考文章：https://www.jianshu.com/p/d5b59278596e