Android HandlerThread 源码解析

前言

这个东西看着很高端的感觉，刚开始没明白这是用来干啥用的，他的源码也很简单，简单到都想不出来他的场景，后面看到以博客毛瑟顿开，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 初衷，即在一个独立的线程中处理消息～

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