HandlerThread运行机制和使用方法

前置知识：Handler、Looper原理，可以参考我的另一篇文章 http://blog.csdn.net/lizhengwei1989/article/details/68066478

先说一下HandlerThread的基本用法：

        //创建一个线程,线程名字：handler-thread
        myHandlerThread = new HandlerThread( "handler-thread") ;
        //开启线程
        myHandlerThread.start();
        //在这个线程中创建一个handler对象
        handler = new Handler( myHandlerThread.getLooper() ){
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                //这个方法是运行在 handler-thread 线程中的 ，可以执行耗时操作
            }
        };

        //用handler发送消息，就会在handler的handleMessage方法中收到消息
        handler.sendEmptyMessage( 1 ) ;
        // 最后不用的时候要释放
        myHandlerThread.quit() ;

下面结合源码分析一下HandlerThread的原理：

public class HandlerThread extends Thread {
    int mPriority;
    int mTid = -1;
    // 和这个线程绑定的Looper
    Looper mLooper;

    // 构造函数
    public HandlerThread(String name) {
        super(name);
        mPriority = Process.THREAD_PRIORITY_DEFAULT;
    }

    public HandlerThread(String name, int priority) {
        super(name);
        mPriority = priority;
    }

    /**
     * Looper消息循环开始之前的回调
     */
    protected void onLooperPrepared() {
    }

    @Override
    public void run() {
        mTid = Process.myTid();
        Looper.prepare(); // 实例化此线程的Looper
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop(); // 开启消息循环，此时线程就会阻塞在这，有消息加到消息队列就会被处理，直到调用了自身的quit()方法，消息循环终止，才会向后执行，线程run方法体执行完毕，线程死亡。这里涉及到Handler和Looper的运行机制，不清楚的建议参考前面提到的文章学习一下
        mTid = -1;
    }

    // 获取当前线程的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;
    }

    // 关闭当前线程
    public boolean quit() {
        Looper looper = getLooper();
        if (looper != null) {
            // 其实就是调用了looper的quit方法中断了消息循环
            looper.quit();
            return true;
        }
        return false;
    }

    // 和quit方法类似
    public boolean quitSafely() {
        Looper looper = getLooper();
        if (looper != null) {
            looper.quitSafely();
            return true;
        }
        return false;
    }

    public int getThreadId() {
        return mTid;
    }
}

总结一下HandlerThread的工作原理：
线程启动以后就会进入阻塞状态，有消息添加到阻塞队列就会处理消息。当不需要的时候调用quit()方法终止消息循环，线程停止。