Handler流程梳理

理一下Handler消息分发流程,一定离不开这几个类:
Handler:用于消息发送和接收
Message:消息
MessageQueue:消息队列,用于存储消息
Looper:循环取出从MessageQueue中的Message

分三点说起,Handler的创建、消息的发送、消息的接收

一、Handler的创建

首先从new Handler开始看看Handler初始化的时候都做了什么:

    //Handler源码
    public Handler(Callback callback, boolean async) {
        ...

        mLooper = Looper.myLooper();
        ...
        mQueue = mLooper.mQueue;
        mCallback = callback;
        ...
    }

内容很简单,mLooper、mQueue、mCallback的赋值,mCallback没什么说的,我们初始化的时候传递过来的:

    private Handler handler = new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(Message msg) {
            //消息处理
            return false;
        }
    });

那这里的mLooper是怎么来的?而且mQueue的赋值也是取的mLooper.mQueue,跟进去这个Looper.myLooper()方法:

    public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
    }

关于ThreadLocal在Handler常见疑问的最后写过了,这里需要疑问的是sThreadLocal什么时候set的。主线程的Looper是在ActivityThread中创建的,ActivityThread是App一启动就会调用的,去从ActivityThread的main方法开始跟起:

    public static void main(String[] args) {
        ...

        Looper.prepareMainLooper();

        ...
        Looper.loop();

        ...
    }

先跟这个prepareMainLooper()方法:

    public static void prepareMainLooper() {
        prepare(false);
       ...
    }
    ...
    private static void prepare(boolean quitAllowed) {
        ...
        sThreadLocal.set(new Looper(quitAllowed));
    }

到这里就已经找到了主线程中Looper的创建,是在APP一启动就创建了。然后再看看Looper.loop();做了什么:

    public static void loop() {
        final Looper me = myLooper();
        ...
        final MessageQueue queue = me.mQueue;

        ...

        for (;;) {
            Message msg = queue.next(); // might block
            ...
            msg.target.dispatchMessage(msg);
            ...
            msg.recycleUnchecked();
        }
    }

这里的for是一个无限循环,不断的从MessageQueue中取出消息并且分发,这段代码先留着,一会到消息发送的时候再具体看,先看前两句,获取Looper并且获取Looper中的MessageQueue,myLooper()刚才看过了,还是调用sThreadLocal.get();获取的Looper对象,那MessageQueue是什么时候创建,这里的me是个Looper的实例,那mQueue肯定是Looper的一个全局属性,mQueue是在Looper的构造函数中赋值的:

    private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }

这个牵扯出个跟主流程无关的问题,构造函数会发现是私有的,为什么这样处理?那是怎么提供给外界的?
上面其实已经贴过了:

    public static void prepare() {
        prepare(true);
    }

    private static void prepare(boolean quitAllowed) {
        ...
        sThreadLocal.set(new Looper(quitAllowed));
    }

就是这个prepare()方法,还是个静态的,在ActivityThread的main函数中调用了,这个结合Handler常见疑问中的ThreadLocal介绍,就很容易理解了,只要是同一个线程中,调用sThreadLocal.get();获取的就是同一个对象。这样保证主线程中的Looper只有一个,MessageQueue作为Looper的属性肯定也只有一个。
总结一下new Handler其实很简单:

  • 得到当前线程中的Looper对象(本篇以主线程为例)
  • 得到Looper中的MessageQueue
  • 接收调用者传递过来的Callback

到这里,必须理清楚的有:

  • 主线程的Looper在App启动的时候已经创建好了,而MessageQueue作为Looper的全局属性也已经在构造函数中创建了,并且Looper已经开始无限循环从MessageQueue中取消息,虽然现在可能没有消息
  • Looper是通过ThreadLocal.get()获取的,所以线程唯一,而MessageQueue作为Looper的全局属性也是线程唯一
  • Handler创建之后已经持有了当前线程(本篇以主线程Handler为例)唯一的Looper、MessageQueue和调用者传递过来的Callback

二、消息发送

Handler创建好之后,从消息的发送开始分析源码,使用代码:

        new Thread(new Runnable() {
            @Override
            public void run() {
                handler.sendMessage(handler.obtainMessage());
            }
        }).start();

直接点进去sendMessage()

    public final boolean sendMessage(Message msg)
    {
        return sendMessageDelayed(msg, 0);
    }
    
    public final boolean sendMessageDelayed(Message msg, long delayMillis)
    {
        ...
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }

    public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
        MessageQueue queue = mQueue;
        ...
        return enqueueMessage(queue, msg, uptimeMillis);
    }

    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        ...
        return queue.enqueueMessage(msg, uptimeMillis);
    }

这都是Handler里的方法,一路跟下来首先在sendMessageAtTime()方法中获取了MessageQueue为mQueue,这里先确定一下,虽然是在子线程调用的sendMessage()方法,但是这个handler还是主线程中的handler,这个一定要清楚,所以根据Handler创建过程的分析可以肯定这里的mQueue是主线程中的MessageQueue,然后在enqueueMessage ()方法中,调用了queue.enqueueMessage()把这个消息压入了主线程的MessageQueue中,跟这个方法之前还有个注意点就是这个msg.target = this,在压入消息之前,把handler本身设置给了msg,也就是msg也持有了hander,这个target只是取的一个名字,他的类型就是Handler:

public final class Message implements Parcelable {
    ...
    Handler target;
    ...
}

继续到MessageQueue中跟上面的压入方法queue.enqueueMessage()

    boolean enqueueMessage(Message msg, long when) {
        ...
        ...
        Message p = mMessages;
        if (p == null || when == 0 || when < p.when) {
            ...
            mMessages = msg;
            ...
        } else {
            // Inserted within the middle of the queue.  Usually we don't have to wake
            // up the event queue unless there is a barrier at the head of the queue
            // and the message is the earliest asynchronous message in the queue.
            ...
        }
        ...
    }

这里的if...else...可以简单理解为如果当前队列里没有消息并且要发送的这个消息没有延迟,就直接赋值给mMessages,否则就加入到消息队列中。
我们跟流程这里不需要看那么复杂,就直接走if中的流程,也就是说我们要发送的这个消息已经赋值给了MessageQueue的全局属性mMessages。
到这里消息发送流程完事,再总结一下上面的流程:

  1. 通过主线程的Handler发送一条message
  2. handler的sendMessage()方法最终是调用了queue.enqueueMessage(message, ...),并且这个message的target指向handler,这里的queue就是主线程的MessageQueue
  3. MessageQueue的enqueueMessage(message, ...)方法接收到这个message并且复制给了自己的全局属性mMessages

三、消息接收

    private Handler handler = new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(Message msg) {
            //消息处理
            return false;
        }
    });

消息接收就是要看handler的handleMessage(Message msg)上面时候被调用,也就是
handler什么时候收到回调。
在第一步Handler的创建的时候,Loop里有一个无限循环,就是从MessageQueue中取消息的,在第二步消息发送的时候已经把Message放入了MessageQueue中(本篇流程设定场景是已经把要发送的Message设置给了MessageQueue中的mMessages)。所以现在就从Looper.loop这个无限循环开始看起,还是Handler创建时候跟到的这段代码:

    public static void loop() {
        final Looper me = myLooper();
        ...
        final MessageQueue queue = me.mQueue;

        ...

        for (;;) {
            Message msg = queue.next(); // might block
            ...
            msg.target.dispatchMessage(msg);
            ...
            msg.recycleUnchecked();
        }
    }

这里通过queue.next()获取到Message对象,并切通过msg.target.dispatchMessage(msg)发送消息。先看queue.next()代码:

    Message next() {
        ...       
        for (;;) {
            ...
            synchronized (this) {
                ...
                Message msg = mMessages;
                ...
                if (msg != null) {
                    ...
                    return msg;
                    ...
                } else {
                   ...
                }
               ...
        }
    }

这个next()返回一个Message对象,而这个对象正是刚才发送消息时候赋值的mMessages,这样就是会说已经拿到了刚才要发送的对象。

这个函数里...的部分是非本篇逻辑的代码,就是上面我们发送消息的时候没考虑多条待处理消息和延迟消息,所以这里也不考虑MessageQueue消息堆积的逻辑,再解释一下就是消息没堆积,MessageQueue中只有一条,发送的时候赋值给mMessages,取的时候从mMessages里取。其实这里如果发送消息的时候发现mMessages有值会有另外的逻辑去存消息,取的时候也就需要相应的逻辑去取,本篇主要梳理Handler工作方式,不展开消息队列的具体工作方式。

拿到消息之后是用过msg.target.dispatchMessage(msg);发送的,而这个target上面分析过其实就是handler,直接去看Handler的dispatchMessage(msg)的方法:

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

这里一看就熟悉了handleMessage(msg)被调用了,也就是handler拿到了回调,收到消息,流程走完。
这个dispatchMessage()方法还有要说的,这里发现有两重if...else判断,首先我们的message没有设置callback,我们设置的是handler的callback,所以直接进来第一次判断的else里,这个问题在Handler常见疑问的Handler两种创建方式里已经写的很明白。那这个第一层if里的逻辑msg.callback流程是怎么样的?这就牵扯出了下一个问题

四、Handler的post()方法

        new Thread(new Runnable() {
            @Override
            public void run() {
                handler.post(new Runnable() {
                    @Override
                    public void run() {
                        Toast.makeText(MainActivity.this, "我是被post出来的吐司", Toast.LENGTH_LONG).show();
                    }
                });
            }
        }).start();

这种使用也不陌生,跟这个post()方法看看:

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

看看这个getPostMessage(r)对Runnable做了什么操作:

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

他把Runnable封装成了一个Message,并且返回,也就是说post (Runnable r)方法把传递过来的Runnable封装成了一个Message,然后调用了sendMessageDelayed(message, ...)方法,而这个Message的callback属性指向了这个Runnable,关于sendMessageDelayed(message, ...)方法不用继续跟了,上面消息发送的时候已经分析的透透的了。到这里就可以继续消息接收中的那个问题:

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

这里的if条件就是这样进来的,然后继续下去这个handleCallback(msg);,跟之前再说一下,这个msg的callback属性是指向子线程中传递过来的一个Runnable,明确之后继续跟handleCallback(msg)

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

非常简单,就一句,调用了message中runnable的run()方法。结合上面的消息发送和接收,总结一下:

  1. 在子线程中通过handler.post(runnable)发送了一个Runnable对象
  2. 把这个Runnable对象封装成Message对象放入到MessageQueue中
  3. 主线程的Looper对象在无限从MessageQueue中取消息,会取出这个带有Runnable的Message
  4. 取出后执行Message对象中Runnable的run()方法

再仔细想一下这个post()方法,这就是Handler实现线程切换的流程,本例中Handler、Loop、MessageQueue都是主线程中的,子线程里把一个Runnable对象封装成Message对象放入到主线程Loop对象的MessageQueue,直到这个Message被取出,调用了message.runnable.run()

完事。

推荐阅读更多精彩内容