Handler源码分析

Handler:

Handler主要是用于异步消息的处理：当发出一个消息之后，首先进入一个消息队列，发送消息的函数即刻返回，而另外一部分在消息队列中逐一将消息取出，然后对消息进行处理。

问题：
  1. Handler(Callback) 跟 Handler() 这两个构造方法的区别在哪， Handler什么情况下会内存泄漏？
  2. 刷新UI为什么只能在主线程中执行
  3. 为什么创建 Message 对象推荐使用 Message.obtain()获取？
  4. Threadlocal用法和原理
  5. 为什么 Handler 能够切换线程执行？
  6. Looper.loop() 为什么不会造成应用卡死？
问题1
   Handler handler2 = new Handler() {
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
        }
    };

但是这样会报黄色警告。大体意思就是说handler应该为静态。否则会造成内存泄漏。
MessageQueue中的消息队列会一直持有对handler的引用，而作为内部类的handler会一直持有外部类的引用，就会导致外部类不能被GC回收。当我们发延时很长的msg时就容易出现泄漏。

1.新建静态类继承Handler.
所以此处应该设置为static，然后Handler就会跟随类而不是跟随类的对象加载，也就不再持有外部类的对象引用。

2.使用Handler.Callback()

   Handler handler1 = new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(@NonNull Message msg) {
            return false; 
        }
    });

  /**
     * Callback interface you can use when instantiating a Handler to avoid
     * having to implement your own subclass of Handler.
     */
    public interface Callback {
        /**
         * @param msg A {@link android.os.Message Message} object
         * @return True if no further handling is desired
         */
        boolean handleMessage(@NonNull Message msg);
    }

     /**
     * Handle system messages here.
     */
    public void dispatchMessage(@NonNull Message msg) {
        if (msg.callback != null) {  //若callback不为空，代表使用post(Runnable r)发送消息
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);//创建Handler实例时复写
        }
    }

问题二： 刷新UI为什么只能在主线程中执行

问题三：为什么创建 Message 对象推荐使用 Message.obtain()获取？

/**
     * Return a new Message instance from the global pool. Allows us to
     * avoid allocating new objects in many cases.
     */
     public static Message obtain() {
        synchronized (sPoolSync) {
            if (sPool != null) {
                 Message m = sPool;
                 sPool = m.next;  //spool指向下一个缓存对象
                 m.next = null;
                 m.flags = 0; // clear in-use flag
                 sPoolSize--；
                 return m;
            }
        }
        return new Message();
    }
image.png

sPool 消息缓存池，若消息池不为空，则从头节点取出，置为非使用状态。若消息池为空，则新建一个Message。

private static final int MAX_POOL_SIZE = 50;
void recycleUnchecked() {
        // Mark the message as in use while it remains in the recycled object pool.
        // Clear out all other details.
        flags = FLAG_IN_USE;
        what = 0;
        arg1 = 0;
        arg2 = 0;
        obj = null;
        replyTo = null;
        sendingUid = UID_NONE;
        workSourceUid = UID_NONE;
        when = 0;
        target = null;
        callback = null;
        data = null;

        synchronized (sPoolSync) {
            if (sPoolSize < MAX_POOL_SIZE) {
                next = sPool;
                sPool = this;
                sPoolSize++;
            }
        }
    }
image.png

在Looper.loop()方法中，当msg消息处理完毕，则会调用上面Message的回收方法，将消息的参数清空，若消息池的数量少于50，则将消息插入缓存池的头结点。

问题四：Threadlocal用法和原理

ThreadLocal.java
  public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

   public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }
  void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

可以看到上面代码，在存储和取 是以当前线程为key，looper为value。 在Handler初始化的时候会检查是否能取到looper，否则抛出异常！

ThreadLocal的作用是不同的线程拥有该线程独立的变量，同名对象不会被受到不同线程间相互使用出现异常的情况。
即：你的程序拥有多个线程，线程中要用到相同的对象，但又不允许线程之间操作同一份对象。那么就可以使用ThreadLocal来解决。它可以在线程中使用mThreadLocal.get()和mThreadLocal.set()来使用。若未被在当前线程中调用set方法，那么get时为空。

image.png

问题五：为什么 Handler 能够切换线程执行？

image.png

Handler 发送的线程不处理消息，只有Looper.loop()将消息取出来后再进行处理，所以在Handler机制中，无论发送消息的Handler对象处于什么线程，最终的处理都是运行在 Looper.loop() 所在的线程。

问题六：Looper.loop() 为什么不会造成应用卡死？

这里我们先看张流程图：


image.png

MessageQueue.java

boolean enqueueMessage(Message msg, long when) {  //when = SystemClock.uptimeMillis() + delayMillis
     ...
        synchronized (this) {//线程同步
            if (mQuitting) {
                IllegalStateException e = new IllegalStateException(
                        msg.target + " sending message to a Handler on a dead thread");
                Log.w(TAG, e.getMessage(), e);
                msg.recycle();
                return false;
            }
            msg.markInUse();
            msg.when = when;    //赋值调用时间
            Message p = mMessages;
            boolean needWake;
            if (p == null || when == 0 || when < p.when) {
                // New head, wake up the event queue if blocked.
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
                needWake = mBlocked && p.target == null && msg.isAsynchronous();
                Message prev;
                for (; ; ) { //根据消息（Message）创建时间插入到队列中
                    prev = p;
                    p = p.next;
                    if (p == null || when < p.when) {
                        break;
                    }
                    if (needWake && p.isAsynchronous()) {
                        needWake = false;
                    }
                }
                msg.next = p; // invariant: p == prev.next
                prev.next = msg;
            }
            // We can assume mPtr != 0 because mQuitting is false.
            if (needWake) {
                nativeWake(mPtr);
            }
        }
        return true;
    }

这里可以看到传递的msg根据当前是否有message需要返回和messge的执行时间（when）排序。


image.png

这里mMessages不为空时为当前链表的第一个Message，当有message需要执行的时候，会调用
nativeWake(mPtr)方法，（将主线程唤醒）

这里Looper.loop()方法时一直在主线程循环的执行的。

public static void loop() {
        final Looper me = myLooper();
        ...
        final MessageQueue queue = me.mQueue;
        ...
        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                return;
            }
            ...
            msg.target.dispatchMessage(msg);  //派发消息到对应的Handler
            ...
        }
    }

这里面主要是next方法。msg.target为 Handler。会将从messageQueue中取message传递出去。
下面看下 dispatchMessage方法

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

dispatchMessage方法里面针对 Handler发送Message方式做了处理。
下面重点看看下next()方法。取消息的方法。

 Message next() {
      ...
        int pendingIdleHandlerCount = -1; // -1 only during first iteration
        int nextPollTimeoutMillis = 0;  ////阻塞时间：-1是一直阻塞不超时；0是不会阻塞，立即返回；大于0则nextPollTimeoutMillis是最长阻塞时间，期间有线程唤醒立即返回
        for (; ; ) {
            if (nextPollTimeoutMillis != 0) {
                Binder.flushPendingCommands();
            }
            nativePollOnce(ptr, nextPollTimeoutMillis);
            synchronized (this) {
                // Try to retrieve the next message.  Return if found.
                final long now = SystemClock.uptimeMillis();
                Message prevMsg = null;
                Message msg = mMessages;
                if (msg != null && msg.target == null) {
                    // Stalled by a barrier.  Find the next asynchronous message in the queue.
                    do {
                        prevMsg = msg;
                        msg = msg.next;
                    } while (msg != null && !msg.isAsynchronous());
                }
                if (msg != null) {
                    if (now < msg.when) {  //when是消息传递的目标时间
                        // Next message is not ready.  Set a timeout to wake up when it is ready.
                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);//计算消息等待时间
                    } else {
                        // Got a message.
                        mBlocked = false;
                        if (prevMsg != null) {
                            prevMsg.next = msg.next;
                        } else {
                            mMessages = msg.next;
                        }
                        msg.next = null;// 清除next
                        if (DEBUG) Log.v(TAG, "Returning message: " + msg);
                        msg.markInUse();
                        return msg;
                    }
                } else {
                    // No more messages.
                    nextPollTimeoutMillis = -1;   // 若 消息队列中已无消息，则将nextPollTimeoutMillis参数设为-1 下次循环时，消息队列则处于等待状态
                }
        ...
        }
    }

nextPollTimeoutMillis：

-1是一直阻塞不超时；
0是不会阻塞，立即返回；
大于0则nextPollTimeoutMillis是最长阻塞时间，期间有线程唤醒立即返回

1.若当前取出的mMessage为空，则将nextPollTimeoutMillis置为-1，然后调用 nativePollOnce(ptr, nextPollTimeoutMillis);会将线程阻塞在这里。
2.若当前取出消息时间还没到，则计算出需要等待时间，阻塞线程
3.将消息的next置为null，给mMessages = msg.next;赋于下一个msg。并将message返回出去。

特别注意

  • 1个线程（Thread）只能绑定 1个循环器（Looper），但可以有多个处理者（Handler）
  • 1个循环器（Looper） 可绑定多个处理者（Handler）
  • 1个处理者（Handler） 只能绑定1个1个循环器（Looper）
image

Handler发送消息的两种方式

Handler.post(Runnable r){}
Handler.sendMessage(Message msg){}

image.png

post系列方法传入的Runnable中若持有Context的引用，会造成内存泄漏吗？
显然是会的。Runnable会被封装成Message加入到消息队列中，只要该消息不被处理或者移除，消息队列就会间接持有Context的强引用，造成内存溢出，所以，如果该Handler是针对一个Activity的操作，在Activity的 onDestory()回调函数中中一定要调用removeCallbacksAndMessages()来防止内存泄漏。

链接：

Android中为什么主线程不会因为Looper.loop()里的死循环卡死？

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