Handler消息机制之流程解析

Hanlder中Messsage的发送和处理过程

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

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

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