Android-异步消息处理机制2 -HandlerThread的介绍

本文为转载。在整理珍藏的学习笔记时翻出了这些资料，这些文章在我理解 Android 的过程中给予了很大帮助。

原文在github上，国内经常连接不上去，在这里贴出来，希望能够帮到更多的人。

本文的转载未改动任何内容，请大家去支持原作者

原文链接

之间在上篇文章中介绍过了Android的异步消息处理机制，这里再进行一些补充，说下多线程中的消息处理以及HandlerThread的介绍，如果你还不是很了解handler的机制，可以先看看上篇文章Android-异步消息处理机制(Handler,Looper,Message)

在上篇文章中开头说过我们平时在子线程中去更新ui的操作一般是通过handler来发送message的方式进行处理，但是其实还有几种更简便的方式来进行ui的操作：

1. Handler的post()方法
2. View的post()方法
3. Activity的runOnUiThread()方法
   代码如下：

   12345678910111213141516171819202122232425262728293031323334353637

   new Thread(new Runnable() {    @Override    public void run() {        //1.普遍的方式        //发送消息        Message msg = Message.obtain();        msg.what = 111;        Bundle bundle=new Bundle();        bundle.putString("huan","hello");        msg.setData(bundle);        mHandler.sendMessage(msg);        //2.post的方式        mHandler.post(new Runnable() {            @Override            public void run() {                //可以直接在这儿进行ui的更新            }        });        //3.view.post方式        mTvHelloWord.post(new Runnable() {            @Override            public void run() {                //可以直接在这儿进行ui的更新            }        });        //4.runOnUiThread方式        runOnUiThread(new Runnable() {            @Override            public void run() {                //可以直接在这儿进行ui的更新            }        });    }}).start();

从代码中可以明显的看出，后面三种方式要简便的多，而且是一种比一种简便，都不需要通过Message 的创建去封装消息；第二种方式还需要使用handler作为载体，第三种方式需要使用view来作为载体，第四种方式直接用runOnUiThread方法即可。为什么可以这样写也能达到目的？进去看看知道了。

1. 先说下handler post方式的使用，我们不需要再去创建一个Message对象，把数据封装在Message中，然后在handler的callback中进行ui的操作，而是直接可以在run中进行操作。进入到post方法中：

   1234

   public final boolean post(Runnable r){   return  sendMessageDelayed(getPostMessage(r), 0);}

所噶，原来还是通过sendMessageDelayed(Message msg, long delayMillis)这个方法来进行操作的，并且将我们传入的runnable对象通过getPostMessage方法转为了一个Message;那我们再进入getPostMessage方法中一看应该就能明了了：

12345

private static Message getPostMessage(Runnable r) {    Message m = Message.obtain();    m.callback = r;    return m;}

创建了一个消息，并把这个消息的callback设置为了我们传入的runnnable；还记得我们上篇文章说过的在Looper进行消息循环的时候，取出来的消息将会通过dispatchMessage这个方法进行处理：

123456789101112

public void dispatchMessage(Message msg) {    if (msg.callback != null) {        handleCallback(msg);    } else {        if (mCallback != null) {            if (mCallback.handleMessage(msg)) {                return;            }        }        handleMessage(msg);    }}

首先判断的就是msg的callback是否为null，如果不为null就会执行handleCallback(msg)：

123

private static void handleCallback(Message message) {    message.callback.run();}

直接调用了msg的runnable对象也就是我们一开始传给msg的runnable对象，瞬间就很清晰明了了。

1. view.post方式
   view.post方法和handler的写法几乎一致，看看它的里面实现了什么：

   123456789

   public boolean post(Runnable action) {    final AttachInfo attachInfo = mAttachInfo;    if (attachInfo != null) {        return attachInfo.mHandler.post(action);    }    // Assume that post will succeed later    ViewRootImpl.getRunQueue().post(action);    return true;}

原来就是通过attachInfo获取到了handler，然后执行handler的post方法而已。换汤不换药。

1. runOnUiThread方式
   这个方法其实是属于Activity的方法，也就是只能在Activity中才能使用，代码如下：

   1234567

   public final void runOnUiThread(Runnable action) {    if (Thread.currentThread() != mUiThread) {        mHandler.post(action);    } else {        action.run();    }}

首先判断了当前线程是否是ui线程，如果不是，就用handler post的方式；否则就直接run。

看完了这三种方式的源代码发现其实底层都是通过handler发送message 的方式来进行消息的处理；所以平时我们在开发android的过程中如果明白了handler的消息机制；那么这几种方法你都是可以任意使用的，哪种方便用哪种。

Looper和handler的同步关系：

接下来说下在多线程中handler和looper的处理；先模拟一个运行场景：

1. 主线程中开启一个线程1；线程1开启的时候会启动线程2；
2. 线程2启动后获取到Looper,并执行looper.loop ；
3. 将线程2中的looper对象赋值给线程1中的looper对象
4. 通过线程1中的looper对象，在主线程中创建一个hanlder对象；
5. 通过handler发送一个msg，请问这个msg是在哪个线程中收到这个消息并进行处理；

看下代码：
线程1:

1234567891011121314151617181920212223242526272829

public class LooperThread1 extends Thread {    /**     * 定义一个public的成员变量Looper     */    public Looper myLooper = null;    /**     * 初始化Looper,开启消息循环     */    public void initLooper(){        Looper.prepare();        myLooper = Looper.myLooper();        Looper.loop();    }    @Override    public void run() {        //开启另一个线程        Thread thread2 = new Thread(new Runnable() {            @Override            public void run() {                initLooper();            }        });        thread2.start();        Log.e("test", "thread2 id:" + thread2.getId());    }}

主线程：

12345678910111213141516171819

//主线程idLog.e("test", "Main Thread:" + Thread.currentThread().getId());LooperThread1 myLooperThread1=new LooperThread1();myLooperThread1.start();//线程1 idLog.e("test","thread1 id:"+myLooperThread1.getId());Looper looper=myLooperThread1.myLooper;android.os.Handler handler=new android.os.Handler(looper, new android.os.Handler.Callback() {    @Override    public boolean handleMessage(Message msg) {        if(msg.what==111){            Log.e("test","handleMessage :111");            //当前线程            Log.e("test","current Thread:"+Thread.currentThread().getId());        }        return false;    }});handler.sendEmptyMessage(111);

最开始我是为了验证这个handler发送的消息最终是在哪个线程中接收，但是其实这段代码是有问题的，一运行会报java.lang.NullPointerException。具体的原因就在与：创建handler的时候，传入的这个looper为空。我们在获取线程1的looper对象时，这个时候可能线程2还没有执行完获取到looper；所以问题就出在这儿；不过我们可以加一个同步锁的方式来解决，但是如果每次写你都去这样操作那不是很麻烦？ 所以，android给我们推荐了一个 HandlerThread线程来解决多线程中handler和looper之间同步的问题。

HandlerThread中的源码：

123456789101112131415161718192021222324252627282930313233343536

@Overridepublic 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中自动帮我们创建好了looper；那么我们接下来再来验证下消息的处理是在哪个线程：

123456789101112131415

//主线程idLog.e("test", "Main Thread:" + Thread.currentThread().getId());HandlerThread handlerThread = new HandlerThread("handler_thread");handlerThread.start();Log.e("test", "HandlerThread:" + handlerThread.getId());android.os.Handler handler=new android.os.Handler(handlerThread.getLooper(), new android.os.Handler.Callback() {    @Override    public boolean handleMessage(Message msg) {        if(msg.what==222){            Log.e("test","receiveMsh thread id:"+Thread.currentThread().getId());        }        return false;    }});handler.sendEmptyMessage(222);

打印log为：

得出结论：handler发送的Message处理，不会依赖与创建handler时所在的线程，依赖与传入的looper对象所在的线程，looper所在的线程来执行msg的处理；

到这里，通过两篇文章总算是将handler这个知识点大部分总结完了；接下来会继续总结其他技术点的知识；如果文章有疏漏，错误，望君能给我评论指出。谢谢！