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

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

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

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

   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方法中：

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

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

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

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

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)：

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

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

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

   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中才能使用，代码如下：

   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:

public class LooperThread1 extends Thread {

    /**     * 定义一个public的成员变量Looper     */
     * 定义一个public的成员变量Looper
     */
    public Looper myLooper = null;

    /**     * 初始化Looper,开启消息循环     */
     * 初始化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());
    }
}

主线程：

//主线程id
Log.e("test", "Main Thread:" + Thread.currentThread().getId());
LooperThread1 myLooperThread1=new LooperThread1();
myLooperThread1.start();
//线程1 id
Log.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中的源码：

@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. */
 * 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；那么我们接下来再来验证下消息的处理是在哪个线程：

//主线程id
Log.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这个知识点大部分总结完了；接下来会继续总结其他技术点的知识；如果文章有疏漏，错误，望君能给我评论指出。谢谢！