一步步搞懂Handler的工作原理（源码分析）

最新推荐文章于 2024-07-27 17:24:37 发布

HelloTu

最新推荐文章于 2024-07-27 17:24:37 发布

阅读量784

点赞数

分类专栏： android基础文章标签： android Handler Looper MessageQueue 线程通信

本文链接：https://blog.csdn.net/TMACADAI/article/details/90633952

版权

android基础专栏收录该内容

7 篇文章 0 订阅

订阅专栏

在前一篇文章搞懂Handler的使用与工作流程中讲了下Handler的使用方式，并简单介绍了Handler实现线程通信的流程，这篇文章将继续结合Handler的使用，一步步分析源码看看具体都干了什么，彻底搞清楚Handler，Message，ＭessageQueue以及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，Looper对象与线程1是绑定的关系，创建的Handler对象与这个Looper对象也实现了绑定。在线程2中用这个Handler对象发送一个消息Message对象，这个消息就进入了线程1绑定的Looper对象的MessageQueue队列中，然后线程1中调用的Looper.loop()方法内就会获取到这个消息，把消息交给Handler处理，实现了消息从线程2传递到线程1。

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

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

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

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