前言

这个东西看着很高端的感觉，刚开始没明白这是用来干啥用的，他的源码也很简单，简单到都想不出来他的场景，后面看到以博客毛瑟顿开，HandlerThread的特点，大概就是说，它用子线程的Looper，使我们的消息在子线程中处理，通常我们都是绑定了主线程的 MessageQueue，一定程度上加大了主线程消息处理的负担。在子线程中处理消息，自然也不能处理消息，可以处理一些后台的任务，但是他是串行处理，所以使用时要注意了。

HandlerThread 是什么东西？

先看名字，有 Handler，又有 Thread，聪明的你一想就知道了，他是一个 Thread，既然是Thread，那就有 Thread 的特性，比如你可以 start 启动线程。回到正题，其实他就是一个帮你初始化了一个子线程 Looper 的 Thread，那他的使用就是获取这个Looper，绑定到Handler，就可以使处理消息的代码执行在子线程。

前世今生

继承自Thread，使用时可以调用 .start()，注意 run 和 start 的区别

public class HandlerThread extends Thread {}

源码分析

属性

• mPriority 是线程的优先级，默认为Process.THREAD_PRIORITY_DEFAULT，注意，安卓的线程优先级比 Java 的影响要大，虽然 JVM 是抢占式地优先级调度，但其实并不能保证这个语义，开发者不应该完全依赖这个。
• mTid 是线程 id
• mLooper Looper对象
• Handler 对象

    int mPriority;
    int mTid = -1;
    Looper mLooper;
    private @Nullable Handler mHandler;

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

函数

run 函数很简单，先 Looper.prepare()，给当前线程的初始化一个 Looper 对象，需要注意的是，这个方法不能在当前线程多次调用，会抛出 new RuntimeException("Only one Looper may be created per thread"); 异常，不明白的可以去看这一篇Handler 源码大白话。有一个 onLooperPrepared() 方法你可以去重写，主要是 Looper.loop() 调用前的一些准备操作

    /**
     * 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();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }

获取Looper，代码简单易懂，需要注意，如果线程还活着，如果 looper 为空，那么则阻塞等待初始化，这里使用了 synchronized 以及 wait notify 机制，有时间得好好研究一下这个机制，总感觉掌握的还不够

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

关闭Looper，或者使用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;
   }

一个简单的例子（纯手写,不保证对）

@MainThread

private HandlerThread mHT = new HandlerThread("WorkerHandler");
private Handler mH;

@Override
public void onCreate(Bundle savedInstanceState) {
      mHT.start();
      
      mH = new Handler(mHT.getLooper()) {
               @Override
              public void handleMessage(Message msg) {
                    Log.v("mhT", "I received the msg: " + msg + " from" + Thread.currentThread());
              }
      };
}

@Override
public void onDestroy() {
      mHT.quitSafely();
}

小结

如果我们的消息不需要更新UI，可以考虑使用这种子线程消息处理模式。当然，你也可以传入主线程的 Looper，但这违背了 HandlerThread 初衷，即在一个独立的线程中处理消息～

欢迎讨论，如果有了新的理解，会不断更新～