本来准备今天整理一下IntentService的源码解析，但是发现必须先总结一个HandlerThread的知识点才可以讲它，所以我今天就讲一下HandlerThread的使用及源码解析。

HandlerThread的使用

 public void startHandlerThread(){
        final HandlerThread myHandlerThread = new HandlerThread("myHandlerThread");
        myHandlerThread.start();
        workHandler = new Handler((myHandlerThread.getLooper())){
            @Override
            public void handleMessage(Message message){
                super.handleMessage(message);
                switch (message.what){
                    case 0:
                        Log.d(TAG, "收到来自主线程的消息.."+Thread.currentThread().getName());
                        break;
                    case 1:
                        Log.d(TAG, "收到来自子线程的消息.."+Thread.currentThread().getName());
                        break;
                }
            }
        };
        workHandler.sendEmptyMessage(0);
        new Runnable(){
            @Override
            public void run() {
                workHandler.sendEmptyMessage(1);
            }
        }.run();

    }

程序运行结果打印如下

02-26 20:06:34.195 30062-30101/com.txVideo.demo D/LoadingActivity: 收到来自主线程的消息..myHandlerThread
02-26 20:06:34.195 30062-30101/com.txVideo.demo D/LoadingActivity: 收到来自子线程的消息..myHandlerThread

这段代码中我们创建了一个HandlerThread的实例对象myHandlerThread，并在workHandler中执行相关的操作.最终可以就看出不管是在主线程还是子线程发送消息，都是在这个myHandlerThread线程中工作。

源码分析

首先我们开始看HandlerThread.java的源码

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;
    }
    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;
    }
    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;
    }
  @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其本质是Thread的子类，也就是一个子线程，里面有三个常量

    int mPriority;
    int mTid = -1;
    Looper mLooper;

• mPriority表示线程的优先级
• mTid表示线程的标识符
• mLooper一个Looper实例，这是HandlerThread与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对象的loop方法，然后当我们开始运行这个HandlerThread实例对象时，它的Looper也就开始了循环.那如何停止它呢？

 public boolean quit() {
        Looper looper = getLooper();
        if (looper != null) {
            looper.quit();
            return true;
        }
        return false;
    }

停止时就用到了上述的quit()方法。
那么接下来我们通过用法结合HandlerThread线程的原理，来分析一下它的运行过程。那么回到我们最开始的使用来逐行分析。

 final HandlerThread myHandlerThread = new  HandlerThread("myHandlerThread");
 myHandlerThread.start();

这里我们创建了一个HandlerThread的实例对象myHandlerThread,通过调用start()方法来开启了这个线程中的Looper循环。

        workHandler = new Handler((myHandlerThread.getLooper())){
            @Override
            public void handleMessage(Message message){
                super.handleMessage(message);
                switch (message.what){
                    case 0:
                        Log.d(TAG, "收到来自主线程的消息.."+Thread.currentThread().getName());
                        break;
                    case 1:
                        Log.d(TAG, "收到来自子线程的消息.."+Thread.currentThread().getName());
                        break;
                }
            }
        };

接下来我们创建了一个执行myHandlerThread的工作handler，它负责HandlerThread做实际的业务，它在创建时，通过myHandlerThread的getLooper()方法来获取Looper对象，然后利用这个Looper对象来创建了这个Handler，从上篇Handler的源码分析中我们可以得知，每一个Looper维护了自己的一个消息队列，因此当我们给这个Handler发送消息时，其实也就是给myHandlerThread线程里的Looper对象发送消息，因此我们只需要在执行业务时调用

workHandler.sendEmptyMessage(0); //主线程发送消息
        new Runnable(){
            @Override
            public void run() {
                workHandler.sendEmptyMessage(1);
            }
        }.run(); // 子线程里发送消息

我们可以通过打印结果看出其都是运行在myHandlerThread的线程中的，当我们使用完毕时，还需要关闭myHandlerThread中的Looper循环，也就是调用如下代码

myHandlerThread.quit()

HandlerThread的使用还是很简单的，那么接下来我们总结一下它的工作原理:

• 新创建一个HandlerThread实例对象，并调用start()方法，它会开启线程中的Looper循环，不停地遍历所收到的消息
• 新建一个Handler，它拥有和这个HandlerThread一样的Looper对象，共同接收和遍历同一个消息队列。
• 发送消息给Handler，同时触发HandlerThread中的Looper的消息获取，然后在HandlerThread的线程中就开始执行相对应的处理消息的代码.

总结一下它的特点

• 它是Thread的子类，其本质就是一个单一的子线程
• 因为它和Handler的工作原理类似，所以它的任务执行是串行的不是并行的。
• 使用时结合Handler使用,使用完毕后需手动关闭线程中的Looper循环。

通过全篇的分析，其实HandlerThread就是为了分担主线程中的压力，去做一些其他的操作。
今天的HandlerThread原理就总结到这里啦，觉得对您有帮助记得点个赞~