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

在前一篇文章搞懂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

如图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对象绑定的线程中，有兴趣的可以试一下。

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

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 212,294评论 6赞 493
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,493评论 3赞 385
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 157,790评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,595评论 1赞 284
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,718评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,906评论 1赞 290
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,053评论 3赞 410
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,797评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,250评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,570评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,711评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,388评论 4赞 332
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,018评论 3赞 316
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,796评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,023评论 1赞 266
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,461评论 2赞 360
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,595评论 2赞 350