《Android 异步消息处理机制让你深入理解 Looper、Handler、Message三者关系》观后感

最新推荐文章于 2024-03-22 19:36:57 发布

Android_Study_OK

最新推荐文章于 2024-03-22 19:36:57 发布

阅读量827

点赞数 1

分类专栏：知识点文章标签： handler消息机 looper messageQue

本文链接：https://blog.csdn.net/Android_Study_OK/article/details/51489089

版权

知识点专栏收录该内容

22 篇文章 0 订阅

订阅专栏

引子

今天学习了鸿洋大神的Android 异步消息处理机制让你深入理解 Looper、Handler、Message三者关系，文章写得很精彩，推荐大家都来阅读，在这里做个笔记。

Handler 、 Looper 、Message之间的关系？

Looper负责的就是创建一个MessageQueue，然后进入一个无限循环体不断从该MessageQueue中读取消息msg。
Handler负责（在子线程）发送消息msg、并且（在主线程）处理消息。
（其实严格讲：Handler定义在哪个线程，最终也在哪个线程处理消息，而handler可以在其他任意一个线程去发送消息）

简言之：
1. Looper创建MessageQueue，然后开启死循环，不断地从MessageQueue中取消息
2. Handler发送消息、处理消息

Looper（顺便说了MessageQueue）

对于Looper主要是：构造方法、prepare()和loop()三个方法。

Looper的构造方法
- 创建了一个MessageQueue（消息队列）
Looper.prepare()方法
- 将一个Looper的实例放入了ThreadLocal
- prepare()方法不能被调用两次
- 同时也保证了一个线程中只有一个Looper实例（Only one Looper may be created per thread）
Looper.loop()方法
- looper方法必须在prepare方法之后运行。
- 拿到该looper实例中的mQueue（消息队列）。
- 进入无限循环。
- 从mQueue中取出一条消息，如果没有消息则阻塞。
- 如果有消息，调用消息的 msg.target.dispatchMessage(msg)，把消息交给handler对象的dispatchMessage方法去处理。
- 释放消息占据的资源。

Looper主要作用：
1、与当前线程绑定，保证一个线程只会有一个Looper实例，同时一个Looper实例也只有一个MessageQueue。
2、 loop()方法，不断从MessageQueue中去取消息，交给消息的target属性的dispatchMessage去处理。

Handler

Handler的构造方法中：
- 获取了当前线程保存的Looper实例（因为Looper构造方法已经保证一个线程中只能存在一个Looper实例），从而保证Handler里取到的Looper是同一个Looper。
- 获取了这个Looper实例中保存的MessageQueue（消息队列），这样就保证了handler的实例与我们Looper实例中MessageQueue关联上了。
Handler常用的sendMessage方法:
- sendMessage(Message msg)
- sendEmptyMessageDelayed(int what, long delayMillis)
- sendMessageDelayed(Message msg, long delayMillis)
- sendMessageAtTime(Message msg, long uptimeMillis)
- 辗转反则最后调用了sendMessageAtTime,在此方法内部有直接获取MessageQueue然后调用了queue的enqueueMessage的方法。也就是说handler发出的消息，最终会保存到消息队列中去。

现在已经很清楚了Looper会调用prepare()和loop()方法，在当前执行的线程中保存一个Looper实例，这个实例会保存一个MessageQueue对象，然后当前线程进入一个无限循环中去，不断从MessageQueue中读取Handler发来的消息。然后再回调创建这个消息的handler中的dispathMessage方法，下面我们赶快去看一看这个方法：

Handler的dispathMessage方法：

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

可以看到，第10行，调用了handleMessage方法，下面我们去看这个方法：

  /**
     * Subclasses must implement this to receive messages.
     */
    public void handleMessage(Message msg) {
    }

可以看到这是一个空方法，为什么呢，因为消息的最终回调是由我们控制的，我们在创建handler的时候都是复写handleMessage方法，然后根据msg.what进行消息处理。
例如：

private Handler mHandler = new Handler()
    {
        public void handleMessage(android.os.Message msg)
        {
            switch (msg.what)
            {
            case value:

                break;

            default:
                break;
            }
        };
    };

总结

到此，这个流程已经解释完毕，让我们首先总结一下
1、首先Looper.prepare()在本线程中保存一个Looper实例，然后该实例中保存一个MessageQueue对象；因为Looper.prepare()在一个线程中只能调用一次，所以MessageQueue在一个线程中只会存在一个。
2、Looper.loop()会让当前线程进入一个无限循环，不端从MessageQueue的实例中读取消息，然后回调msg.target.dispatchMessage(msg)方法。
3、Handler的构造方法，会首先得到当前线程中保存的Looper实例，进而与Looper实例中的MessageQueue关联。
4、Handler的sendMessage方法，会给msg的target赋值为handler自身，然后加入MessageQueue中。
5、在构造Handler实例时，我们会重写handleMessage方法，也就是msg.target.dispatchMessage(msg)最终调用的方法。

好了，总结完成，大家可能还会问，那么在Activity中，我们并没有显示的调用Looper.prepare()和Looper.loop()方法，为啥Handler可以成功创建呢，这是因为在Activity的启动代码中，已经在当前UI线程调用了Looper.prepare()和Looper.loop()方法。

答疑：

mHandler.post（Runnable r）为何能直接在r里更改UI，是因为post方法创建了一个类似的UI线程吗

有时候为了方便，我们会直接写如下代码：

mHandler.post(new Runnable()
        {
            @Override
            public void run()
            {
                Log.e("TAG", Thread.currentThread().getName());
                mTxt.setText("yoxi");
            }
        });

其实这个Runnable并没有创建什么线程，而是发送了一条消息，即将我们创建的Runable对象作为callback属性，赋值给了此message。
最终和handler.sendMessage一样，调用了sendMessageAtTime，然后调用了enqueueMessage方法，给msg.target赋值为handler，最终加入MessagQueue.可以看到，这里msg的callback和target都有值，那么会执行哪个呢？
其实上面已经贴过代码，就是dispatchMessage方法：

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

第2行，如果不为null，则执行callback回调，也就是我们的Runnable对象，就不会执行handleMessage(msg)了。

在子线程中创建Handler、Looper

其实Handler不仅可以更新UI，你完全可以在一个子线程中去创建一个Handler，然后使用这个handler实例在任何其他线程中发送消息，最终处理消息的代码都会在你创建Handler实例的线程中运行。

new Thread()  
        {  
            private Handler handler;  
            public void run()  
            {  

                Looper.prepare();  //准备，与当前线程绑定，保证一个线程只会有一个Looper实例，同时一个Looper实例也只有一个MessageQueue。 

                handler = new Handler()  
                {  
                    public void handleMessage(android.os.Message msg)  
                    {  //处理轮询到的消息
                        Log.e("TAG",Thread.currentThread().getName());  
                    };
                };

               Looper.loop();//不断从MessageQueue中去取消息，交给消息的target属性的dispatchMessage去处理
           }；

//在上面的子线程外部的任意一个线程里可以通过handler发送消息，最终在上面的子线程里处理消息
            ................