android Message机制详解

最近被问到Message池最多有多少个？瞬间懵逼了。是该好好来了解下Message机制了。

 

Message源码就不贴了，自己点开看下就好。

一般滴，我们是这么用的：

 

Message msg = Message.obtain();
msg.what = MSG_SHOP;
msg.obj = bean;
handler.sendMessage(msg);

 

为啥这么用呢？人家官网说了：

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#obtainMessage Handler.obtainMessage()} methods, which will pull
* them from a pool of recycled objects.

虽然Message提供了一个公共方法来共造实例，但是最好的方式是调用Message.obtain()来获取，因为当它被回收时会被放入一个对象池中。

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

从obtain()方法我们发现，确实有一个sPool的对象：

private static final Object sPoolSync = new Object(); // 线程锁
private static Message sPool; // 静态消息
private static int sPoolSize = 0; // 当前可用消息池个数

private static final int MAX_POOL_SIZE = 50; // 最大Message数量

private static boolean gCheckRecycle = true;

终于知道Message消息最大个数是多少了MAX_POOL_SIZE = 50;

 

next保存的是下一个可以使用的Message对象，当sPool被使用后，sPool将会指向next，而next被置null，这不就是数据结构中的一个链表吗？也就是说Message池是通过一个链表来实现的！

当第一次调用Mesage.obtain()方法时，sPool肯定是null，所以会new一个Message对象，所以obtain()方法是不会返回为null的，放心使用。

当sPool!= null时，这个时候使用的就是Message池的链表头sPool对象了，然后sPool指向下一个next消息，可用Message数量减一，同时设置message使用标志。

那缓存池到底是怎么实现的呢？上代码：

 

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) {
        if (sPoolSize < MAX_POOL_SIZE) {
            next = sPool;
            sPool = this;
            sPoolSize++;
        }
    }
}

该方法是当Message不被使用时进行回收的代码。

 

当sPoolSize可用Message数量小于最大Message数量50时，就将当前的sPool对象指向下一个next对象，而sPool对象则保存当前的Message对象，sPoolSize再加一。

也就是说，当我们需要获取Message消息时，拿到的是链表头sPool对象；存储时，也是从链表头sPool存储的。即相当于一个Message栈，进出都是最后入栈的Message。

那recycleUnchecked()方法是什么时候调用的呢？

 

public void recycle() {
    if (isInUse()) {
        if (gCheckRecycle) {
            throw new IllegalStateException("This message cannot be recycled because it "
                    + "is still in use.");
        }
        return;
    }
    recycleUnchecked();
}

recycle()回收方法，当Message没有使用后，将进行回收。那这个recycle方法又是什么时候调用的呢？

 

这个就得去分析Looper类了，我们知道在创建Handler前必须调用Looper.prepare()方法，来实例化一个Looper对象。

而在Looper中维持着一个