一步步搞懂Handler的工作原理(源码分析)

在前一篇文章搞懂Handler的使用与工作流程中讲了下Handler的使用方式,并简单介绍了Handler实现线程通信的流程,这篇文章将继续结合Handler的使用,一步步分析源码看看具体都干了什么,彻底搞清楚Handler,Message,MessageQueue以及Looper之间的关系。

平时我们用的最多的可能都是在主线程创建一个Handler对象,然后在子线程利用Handler对象发送消息到主线程处理。现在我们先尝试下在子线程创建Handler,然后在主线程发送消息到子线程,看看能不能行

public class MainActivity extends Activity {

    private final static String TAG = "mainActivity";

    private static final int MSG1 = 1;

    private Handler mHandler;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        new Thread(new Runnable() {
            @Override
            public void run() {
                    mHandler = new Handler() {
                    @Override
                    public void handleMessage(Message msg) {
                        switch (msg.what) {
                            case MSG1:
                                Log.i(TAG, "主线程发来的消息:" + msg.obj);
                                break;
                            default:
                                break;
                        }// End of event ActivityThreadMain.
        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        Looper.loop();
                    }
                };
            }
        }).start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Message msg = Message.obtain();
        msg.what = MSG1;
        msg.obj = "我是主线程";
        mHandler.sendMessage(msg);
    }
}

走你,嗯...崩溃得很流畅...

看看日志:

java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()
        at android.os.Handler.<init>(Handler.java:209)
        at android.os.Handler.<init>(Handler.java:123)
        at com.example.tu.gradletest.MainActivity$1$1.<init>(MainActivity.java:52)
        at com.example.tu.gradletest.MainActivity$1.run(MainActivity.java:52)
        at java.lang.Thread.run(Thread.java:818)

巴拉巴拉一大串调用栈,但有个核心的提示, Can't create handler inside thread that has not called Looper.prepare(),意思大概就是在线程中还没有调用Looper.prepare()的时候,还不能够创造Handler,那我们就按照提示把这个加上

                Looper.prepare();
                mHandler = new Handler() {
                    @Override
                    public void handleMessage(Message msg) {
                        switch (msg.what) {
                            case MSG1:
                                Log.i(TAG, "主线程发来的消息:" + msg.obj);
                                break;
                            default:
                                break;
                        }
                    }
                };

再走你,果然不崩溃了,但是log中并没有打印我们想看到的结果。
但是这会儿也没有异常信息了,只能谷歌一下,发现还需要在最后调用一下Looper.loop(),再试一下

                Looper.prepare();
                mHandler = new Handler() {
                    @Override
                    public void handleMessage(Message msg) {
                        switch (msg.what) {
                            case MSG1:
                                Log.i(TAG, "主线程发来的消息:" + msg.obj);
                                break;
                            default:
                                break;
                        }
                    }
                };
                Looper.loop();

这次终于得到了想要的结果

I/mainActivity: 主线程发来的消息:我是主线程

有人可能会问为什么平时在主线程创建Handler的时候不需要加这两步就能用?
这里先解答下这个问题,实际上在主线程也有这两步,只不过不需要我们主动去调用,系统已经帮我们做好了。

下面我就结合上面的使用过程一步步看下源码都干了些什么

Looper.prepare()

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

    private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

进入prepare方法发现源码很简单,最终的目的其实就是最后一句,给变量sThreadLocal set了一个Looper对象
sThreadLocal是ThreadLocal类型的,从它调用的get,set方法,我们其实可以理解它是存放数据的,而且当前这个sThreadLocal是存放Looper对象的。ThreadLocal最大的一个特点是它存取的对象是线程隔离的,相当于set的对象与当前调用的线程绑定。
具体的ThreadLocal的原理感兴趣的可以看看源码,本文不作详细分析,不然就可能越说越乱了。

总之,调用Looper.prepare()的作用就是初始化了一个属于当前线程的Looper对象。

接下来再点进去看下Looper对象初始化时又干了些什么事

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

可以看到在构造函数中初始化了一个MessageQueue对象,它实际就是一种先进先出的队列,用于存放需要在线程间通信的Message对象。到这里就完成了让一个线程对应上一个Looper,一个Looper对应上一个MessageQueue。

Looper.prepare之后是Handler的初始化

    public Handler(Callback callback, boolean async) {
        if (FIND_POTENTIAL_LEAKS) {
            final Class<? extends Handler> klass = getClass();
            if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                    (klass.getModifiers() & Modifier.STATIC) == 0) {
                Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                    klass.getCanonicalName());
            }
        }

        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;
    }

初始化过程最终是调用到了上面重载的构造函数中,直接看重点,调用Looper.myLooper()赋值给Handler的Looper类型的成员变量mLooper
看看Looper.myLooper()

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

应该还记得前面调用Looper.prepare()的时候为当前线程初始化了一个Looper对象放在了sThreadLocal中,在这里调用get方法取到了这个Looper对象。
再往下看,对拿到的Looper对象进行了判空,如果为空抛出了一个异常"Can't create handler inside thread that has not called Looper.prepare()"
这个异常信息似曾相识,没错,就是我们在前面demo中还没调用Looper.prepare()时程序崩溃抛出的异常。因为没有调用过prepare方法,当前线程没有对应的Looper对象,自然获取到的为空,但是在主线程,这个方法是在程序初始化时就已经调用过,所以不会崩溃

    public static void main(String[] args) {
        ...
        Process.setArgV0("<pre-initialized>");

        Looper.prepareMainLooper();

        ActivityThread thread = new ActivityThread();
        ...
        // End of event ActivityThreadMain.
        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        Looper.loop();
    }

上面的源码是程序的入口函数ActivityThread的main()函数,可以看到这里调用了Looper.prepareMainLooper(),这个就是专门用来为主线程初始化Looper对象的。
另外还可以看到main函数的最后也同样调用了Looper.loop()方法。

到这里,我们初始化的Handler跟Looper对象关联上了

初始化Handler之后是调用了Looper.loop()方法

public static void loop() {
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        final MessageQueue queue = me.mQueue;

        // Make sure the identity of this thread is that of the local process,
        // and keep track of what that identity token actually is.
        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();

        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }

            // This must be in a local variable, in case a UI event sets the logger
            final Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }

            final long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;

            final long traceTag = me.mTraceTag;
            if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
                Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
            }
            final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
            final long end;
            try {
                msg.target.dispatchMessage(msg);
                end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            } 
            ...
        }
    }

这个方法里的代码稍微有些长,不过我们只关心关键的逻辑

首先获取当前线程对应的Looper对象和Looper对应的MessageQueue对象,随后就会开始循环,在循环中会调用MessageQueue对象的next方法,如果没有新消息这个方法会阻塞,若取到了消息,则经过一系列操作之后会调用到msg.target.dispatchMessage(msg),这一步的作用就是处理消息。
我们都是通过Handler对象发送消息的,所以可以猜想下这个Message对象的target肯定和Handler对象有个什么关系。
下面先看下Handler发送消息的过程

点开mHandler.sendMessage(msg)的源码,发现最后调用到自身的enqueueMessage方法

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

该方法第一句就是给msg的target属性赋值为this,说明target其实就是当前Handler对象。

最后调用到了对应MessageQueue对象的enqueueMessage方法,将发送过来的msg加入队列中。

这个时候在Looper的loop方法中,就会从MessageQueue对象中取出这个message,调用Handler对象的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和mCallback是否为空
第一种情况如果都为空的话,最终就会调用handleMessage方法,这个就很熟悉了吧,就是我们在创建Handler对象的时候重写的那个方法,到这,Handler发送消息,到handleMessage处理消息就完成了一次线程间通信。

第二种,当msg.callback和mCallback有不为空的情况时,最终处理消息就不会通过handleMessage方法,那么这两个又是从哪儿来的勒?

我们知道Handler还有种调用post接口的方式,来看下post方法内部的实现

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

实现很简单,直接调用了sendMessageDelayed,这个方法第一个参数是一个Message对象,也就是通过getPostMessage方法将传进去的Runnable对象封装成了一个Message对象,然后sendMessageDelayed也会调用到前面提到的enqueueMessage方法将Message对象加入队列,后面的流程就都一样了

再具体看下怎么把Runnable对象封装成Message对象的

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

很简单,将Runnable对象赋值给了Message对象的callback变量,这样在前面处理信息的方法中msg.callback != null就为true了,会执行handleCallback(msg)方法。

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

直接调用了传进去的Runnable对象的run方法处理消息

对于另外一个判断mCallback != null,这个是因为在Handler中有一个重载的构造函数

    public Handler(Callback callback) {
        this(callback, false);
    }

这种方式就很简单了,把处理逻辑放在Callback对象传入Handler中,最后处理消息就会调用这个Callback对象的handleMessage(msg)方法。

到这里,整个Handler从发送消息,到最后处理消息的所有流程就已经分析完了,总结下

图1

如图1,Looper对象与线程1是绑定的关系,创建的Handler对象与这个Looper对象也实现了绑定。在线程2中用这个Handler对象发送一个消息Message对象,这个消息就进入了线程1绑定的Looper对象的MessageQueue队列中,然后线程1中调用的Looper.loop()方法内就会获取到这个消息,把消息交给Handler处理,实现了消息从线程2传递到线程1。

我认为Handler能够实现线程通信的核心可概括为两点:

  1. 一个Handler对象不是属于某个线程的,在任何线程都可以访问,并发送消息;
  2. Handler对象的创建必须与Looper对象绑定,这样用这个Handler对象从其他线程发送过来的消息都会在这个Looper对象绑定的线程中处理

Handler对象必须与Looper对象绑定是理解Handler机制的关键点,Handler还有个重载的构造函数,是Handler(Looper looper),利用这个构造函数,在没有调用过Looper.prepare的线程中初始化Handler就不会报错,可以正常使用,这时Handler处理消息的线程就到了传入的Looper对象绑定的线程中,有兴趣的可以试一下。

目前还在不断学习中,认知有限,若有不对的欢迎指正

推荐阅读更多精彩内容