android_消息处理机制之Message是如何重复利用的?

  • 问题的引出

我们知道Android开发中我们是一般不会在子线程中去更新UI,而是利用Handler将当前子线程的消息post(Runnable)到主线程中去,这样就可以安全的更新UI了,看过Handler源码的同学应该知道post(Runnable
)底层就是将Runnable转化为Message然后交给Handler去处理的。这时我们发现一个问题,那就是在android中大量的UI更新是不是会创建大量的Message呢?


  • 探究android是如何去处理处理大量的Message

看看Message源码类注释,从下面的注释可以知道,它推荐我们通过Message.obtain()的方式去获取一个Message使用,还有我们看到一个关键字”recycled”,说明通过这个方法获取的Message是从回收池pool中获取的。

/**
 * 
 * Defines a message containing a description and arbitrary data object that can be
 * sent to a {@link Handler}.  This object contains two extra int fields and an
 * extra object field that allow you to not do allocations in many cases.  
 *
 * 

While the constructor of Message is public, the best way to get * one of these is to call {@link #obtain Message.obtain()} or one of the * {@link Handler#obtainMessagerecycleUnchecked Handler.obtainMessage()} methods, which will pull * them from a pool of recycled objects.

*/
  • 关注怎么怎么从回收池中获取Message的

在首次调用obtain方法时,①当前pool中没有Message可用,因此会创建一个Message对象②当前pool有Message可用则直接取出表头Message。现在我发现一个问题,那就是创建了一个Message对象之后,它是什么时候添加到pool中的?

  • next:是Message的属性,是Message类型的,指向的是下一个Messae对象,因此从这点可以看出,它是一个链表的方式实现的。
  • sPoolSync:一个普通的object,纯粹是为了同步锁使用
  • sPool:表头
public static Message obtain() {
    synchronized (sPoolSync) {
        if (sPool != null) {
            Message m = sPool;
            sPool = m.next;
            m.next = null;
            m.flags = 0; // clear in-use flag
            sPoolSize--;
            return m;
        }
    }
    return new Message();
}

public Message() {
}


  • 探索Message是怎么被存到链表中的?

首先我们要Handler的工作需要谁来配合?很简单,那就是Message,MessageQueue和Looper。下面我简单的说说每一个类的作用,详细请参考另一篇博客Handler消息处理机制

  • Message:Handler处理的消息。

  • MessageQueue:消息队列,专门负责存储消息的。
  • Looper:消息轮训器,轮训消息队列获取消息交给Handler去处理。

    知道了上面的关系之后,那么我们得找到切入点,我们知道Looper是负责轮训消息队列的,然后取出消息交给Handler去处理,那么我们就可以猜测它既然可以取消息,那么肯定需要解决handler处理的Message的,追踪源码Looper.loop()瞅瞅:

  • public static void loop() {
        final Looper me = myLooper();
        ...
        for (;;) {//阻塞
            //取出一个消息
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }
            ...
            try {
                //让handler去处理这个消息
                msg.target.dispatchMessage(msg);
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
            //handler处理完消息之后,回收消息
            //关键代码
            msg.recycleUnchecked();
        }
    }
    
    Message:recycleUnchecked
    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 = -1;
        when = 0;
        target = null;
        callback = null;
        data = null;
        synchronized (sPoolSync) {
            //当前pool中的Message还没有超过MAX_POOL_SIZE时
            //将将消息添加到链表中,这里就实现了pool添加Message的操作了
            if (sPoolSize < MAX_POOL_SIZE) {
                next = sPool;
                sPool = this;
                sPoolSize++;
            }
        }
    }
    • 结论

    从Message类的源码注释中也可以看出,它推荐通过Message.obtain()方法获取一个Message对象,这个可以减少内存的消耗,也是比较规范的写法。

    你可能感兴趣的:(Android)