Android HandlerThread最直白的解析

在之前的文章 Android最简单易懂的消息机制（Message MessageQueue Handler Looper）中，我们分析了Android 消息机制中的Message MessageQueue Handler 和Looper，但其实在日常消息机制的使用中，HandlerThread的身影也经常出现，对于一些初学者来说也许很懵逼，那么HandlerThread到底是什么呢？

---

首先用一段很直白的话简单总结下我所理解的HandlerThread：

HandlerThread就是Android帮我们封装了一个Thread，其内部包含有一个已初始化且开始轮循的Looper，然后我们可以将这个Looper取出来，在创建Handler时作为参数赋值进去。体现了Android系统组件的思想，同时也方便了开发者。

---

我们来看下官网对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.

一个启动含有Looper的新线程的便利类。这个Looper可以被用于接下来创建Handler。需要注意的是，ThreadHandler的start()方法必须要被调用。

先来看一下如果不使用HandlerThread，当我们需要在子线程中创建Handler发送消息时，是该如何操作的：

        new Thread() {
            @Override
            public void run() {
                super.run();
                Looper.prepare();

                handlerThr = new Handler(Looper.myLooper()) {
                    @Override
                    public void handleMessage(Message msg) {
                        super.handleMessage(msg);
                        //hanler处理消息
                    }
                };
                Message message1 = Message.obtain();
                message1.what = 1;
                handlerThr.sendMessage(message1);
                Looper.loop();

            }
        }.start();

新建一个线程，调用Looper.prepare()方法，然后新建handler绑定此线程中的looper，调用Looper.loop()开始轮循，是不是感觉很繁琐= =。那如果使用HandlerThread呢：

        HandlerThread handlerThread=new HandlerThread("HandlerThread1");
        handlerThread.start();
        Handler handlerWork=new Handler(handlerThread.getLooper()){
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                //在子线程中进行相关耗时操作

                mUIHandler.sendMessage(msg);//通知主线程进行UI相关操作
            }
        };

1. 创建一个HandlerThread实例对象，传入的字符串是标记作用，可以任意；

2. 调用HandlerThread.start() 方法，开启此线程；

3. 创建一个工作Handler，将handlerThread的looper对象传入，由于这个looper对象是与子线程绑定的，那么这个handlerWork便有了异步的能力，从而在handleMessage方法中就能异步处理一些耗时操作了。

短短三步是不是很简单，清晰明了的将 Looper+Handler+MessageQueue+Thread 的异步循环机制就构建完成了。

---

HandlerThread的使用很简单，它的源码其实更简单，让我们一起看一下：

public class HandlerThread extends Thread {
    int mPriority;
    int mTid = -1;
    Looper mLooper;
    private @Nullable Handler mHandler;

    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对象创建后，便将其赋值给HandlerThread的内部变量mLooper，同时通过notifyAll()唤醒等待线程
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }
    

    public Looper getLooper() {
        //判断当前线程是否启动
        if (!isAlive()) {
            return null;
        }
        
        // If the thread has been started, wait until the looper has been created.
        //这里重点解释下，我们会判断当前线程是否启动和该HandlerThread的mLooper是否为空。因为
        //Looper的创建是在子线程中进行的，而HandlerThread.getLooper()方法是在主线程中进行
        //的，所以我们无法保证调用getLooper()方法时，mLooper已经创建了，那么当发现mLooper为
        //null时，就会调用wait()方法来等待唤醒，而在run()方法中，当Looper()对象创建后，便会调
        //用notifyAll() 方法来唤醒。
        synchronized (this) {
            while (isAlive() && mLooper == null) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
        }
        return mLooper;
    }


    @NonNull
    public Handler getThreadHandler() {
        if (mHandler == null) {
            mHandler = new Handler(getLooper());
        }
        return mHandler;
    }


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


    public int getThreadId() {
        return mTid;
    }
}

首先我们可以看到HandlerThread 的构造方法可以传入一个或两个参数，name指的是线程的名称，可以自己任意定义，而priority指的是线程优先级，可以使用 android.os.Process 中的一些常量值。

然后由于 HandlerThread 继承自Thread，其本质还是个 Thread，所以不要忘了调用 start() 方法，那么在调用 start() 方法后其run() 方法便会执行。

为什么我们不需要调用 Looper.prepare() 与 loop() 方法，就是因为在run()方法中这些都帮我们做了，可以看到首先调用了Looper.prepare() ，然后在调用了 onLooperPrepared() 方法后，开启了循环，所以我们可以在HandlerThread的子类中重写onLooperPrepared() 方法，来做一些初始化操作。

---

至此，我们对HandlerThread的使用与源码就全部分析完了，是不是so easy~