Handler消息机制之流程解析

淩亂°似流年 2022-05-11 01:36 336阅读 0赞

Hanlder中Messsage的发送和处理过程

Handler.sendMessage()
    -->MessageQueue.enqueueMessage()
    -->Looper.next()
    -->MessageQueue.next()
    -->Handler.dispatchMessage()

通过一张图片来加深理解：

![在这里插入图片描述][70]

**Handler类源码分析**

构造方法和属性：

final Looper mLooper;
        final MessageQueue mQueue;
        final Callback mCallback;
        final boolean mAsynchronous;
        
        IMessenger mMessenger;
        
        public Handler() {
            this(null, false);
        }
        public Handler(Callback callback) {
            this(callback, false);
        }
        public Handler(Looper looper) {
            this(looper, null, false);
        }
        public Handler(Looper looper, Callback callback) {
            this(looper, callback, false);
        }
        public Handler(boolean async) {
            this(null, async);
        }
        public Handler(Callback callback, boolean async) {
            mLooper = Looper.myLooper();
            if (mLooper == null) {
                throw new RuntimeException(
                    "Can't create handler inside thread that has not called Looper.prepare()");
            }
            mQueue = mLooper.mQueue;
            mCallback = callback;
            mAsynchronous = async;
        }
        public Handler(Looper looper, Callback callback, boolean async) {
            mLooper = looper;
            mQueue = looper.mQueue;
            mCallback = callback;
            mAsynchronous = async;
        }

**Message的发送过程**：

先来,查看`sendMessage()`: 从message对象添加进去，计算执行时间，最终添加到MessageQueue中。

public final boolean sendMessage(Message msg){
            return sendMessageDelayed(msg, 0);
        }
        public final boolean sendMessageDelayed(Message msg, long delayMillis){
            if (delayMillis < 0) {
                delayMillis = 0;
            }
            return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
        }
        public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
            MessageQueue queue = mQueue;
            if (queue == null) {
                RuntimeException e = new RuntimeException(
                        this + " sendMessageAtTime() called with no mQueue");
                Log.w("Looper", e.getMessage(), e);
                return false;
            }
            return enqueueMessage(queue, msg, uptimeMillis);
        }
        private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
            msg.target = this;
            if (mAsynchronous) {
                msg.setAsynchronous(true);
            }
            return queue.enqueueMessage(msg, uptimeMillis);
        }

再来,看下`post()`方法：

public final boolean post(Runnable r){
           return  sendMessageDelayed(getPostMessage(r), 0);
        }
        private static Message getPostMessage(Runnable r) {
            Message m = Message.obtain();
            m.callback = r;//将Runnable与Message绑定
            return m;
        }

从以上可知，两个方法最终都是转成Message对象，放到MessageQueue队列中，等待执行。

**Message分发处理的过程**：

查看Looper.looo()方法调用的`dispatchMessage()`:

public void dispatchMessage(Message msg) {
            if (msg.callback != null) {
                handleCallback(msg);
            } else {
               //先调用Handler的CallBack接口
                if (mCallback != null) {
                    if (mCallback.handleMessage(msg)) {
                        return;
                    }
                }
                //后调用
                handleMessage(msg);
            }
        }
        //执行Message中Runnable接口的run()
        private static void handleCallback(Message message) {
            message.callback.run();
        }
        
        public void handleMessage(Message msg) {
        }

Handler类中的dispatchMessage（）按以下顺序来分发一个消息：

*  首先，若是Message中callback接口（实际上为Runnable接口）不为空，则执行callback接口对象的run()
 *  其次，若是Handler的mCallback不为空，则调用CallBack的`handleMessage()`
 *  最后才是，调用Handler的`handleMessage()`

[70]: /images/20220511/3787b19081a24f6e959a8596608a9e4d.png