Android进阶系列之2：HandlerThread详解

1 HandlerThread介绍

HandlerThread的本质其实就是Thread封装了Looper。默认情况下，开启一个新的线程时，不会有Looper循环。HandlerThread带个我们的功能是：当开启一个新的线程时，默认帮我们建立好消息循环。方便我们的使用。

2 HandlerThread使用例子

public class MyActivity extends Activity {
    private static final String TAG = "Test-Handler-Thread";
    private static final int MESSAGE_FROM_MAIN_THREAD = 1;
    private static final int MESSAGE_FROM_WORK_THREAD = 2;
    private HandlerThread mHandlerThread;
    private Handler mHandler;


    /**
     * Called when the activity is first created.
     */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        mHandlerThread = new HandlerThread("Handler-Thread");
        mHandlerThread.start();

        mHandler = new Handler(mHandlerThread.getLooper()) {
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);

                switch (msg.what) {
                    case MESSAGE_FROM_MAIN_THREAD:
                        Log.d(TAG, "msg from main thread, handleMessage in thread:" + Thread.currentThread().getName());
                        break;
                    case MESSAGE_FROM_WORK_THREAD:
                        Log.d(TAG, "msg from work thread, handleMessage in thread:" + Thread.currentThread().getName());
                        break;
                }

            }
        };

        Message msg = Message.obtain();
        msg.what = MESSAGE_FROM_MAIN_THREAD;
        mHandler.sendMessage(msg);

        new Thread(new Runnable() {
            @Override
            public void run() {
                Message msg = Message.obtain();
                msg.what = MESSAGE_FROM_WORK_THREAD;
                mHandler.sendMessage(msg);
            }
        }).start();


    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mHandlerThread.quit();
    }
}

以上代码我们构建好HandlerThread以后，调用start()启动这个线程，然后分别在主线程/工作子线程发送消息，交给handler处理。
打印结果如下：

Test-Handler-Thread﹕ msg from main thread, handleMessage in thread:Handler-Thread
Test-Handler-Thread﹕ msg from work thread, handleMessage in thread:Handler-Thread

由此可见，不管是从那个线程发送的消息，handler都会统一在HandlerThread线程中执行。

注意： 在使用HandlerThread时，使用完毕以后，一定要注意调用mHandlerThread.quit()，否则HandlerThread的消息循环一直不会退出，这样会导致消息循环一直存在，这样HandlerThread就不会退出，这样，引用HandlerThread的activity也不会销毁。这样会导致内存泄漏。

3 HandlerThread源码分析

public class HandlerThread extends Thread {
    int mPriority;
    int mTid = -1;
    Looper mLooper;

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

以上代码可以看出，HandlerThread是一个线程。同时线程的优先级设置为默认优先级：Process.THREAD_PRIORITY_DEFAULT.

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

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

比较精彩的是这里run()以及getLooper()方法的设计。分析这段代码之前，我们要明白HandlerThread的使命：它是一个线程，帮我们自动建立好消息循环。OK，牢记这个使命这段代码就比较好懂了。有以下两个事实：
1）由于HandlerThread会和Handler联合起来使用，Handler会通过HandlerThread的getLooper()获取looper；
2）HandlerThread作为一个线程，要启动必须调用start()方法，start()方法调用以后，CPU调度线程以后，会自行run()方法。
run()方法的执行和getLooper()方法的调用是异步的。不管谁最先被调用，必须保证在调用getLooper()的时候，looper已经被初始化，否则就要等待looper被初始化。OK，明白这些隐含的规则以后，我们再来看代码实现。
run()方法中，会首先调用Looper.prepare()，然后执行looper的初始化，这里需要同步。基于前面的分析，run()和getLooper()调用时机异步，所以run()执行的时候，一旦looper初始化，就必须调用notifyAll()，通知被getLooper()阻塞的线程继续执行。
同时在getLooper()中，获取looper时，也必须同步，如果发现looper没有初始化，就wait()阻塞等待looper初始化完毕。
一个小的注意点： 从以上分析可知，一旦HandlerThread的run()没有执行，而先调用了getLooper()，那么调用getLooper()的线程会阻塞等待HandlerThread的start()被调用来触发looper初始化。所以如果getLooper()在主线程调用，为了获取最优性能，最好先调用HandlerThread的start()，然后再去调用getLooper()，如果getLooper()被调用以后，过了很久拆掉用HandlerThread的start()，会或多或少的导致主线程被阻塞一段时间。

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

最后quit()方法，其实就是调用looper的quit来退出消息循环。避免消息循环一直在。所以HandlerThread使用完毕以后，要调用quit方法，否则会有内存泄漏。