【Android自助餐】Handler消息机制完全解析（一）Message中obtain()与recycle()的来龙去脉

客官°小女子只卖身不卖艺 2022-05-23 10:19 105阅读 0赞

# 【Android自助餐】Handler消息机制完全解析（一）Message中obtain()与recycle()的来龙去脉 #

*  【Android自助餐】Handler消息机制完全解析（一）Message中obtain()与recycle()的来龙去脉
    
     *  提供obtain()
     *  回收recycle()

## 提供obtain() ##

在obtain的所有重载方法中，第一行都是`Message m = 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();
    }
      
       
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13

很明显，这是个同步方法，`sPoolSync`即锁对象，该对象在定义时即被初始化`private static final Object sPoolSync = new Object();`，随后便只读不写。  
然后便是`sPool`，后面还有`Message m = sPool;sPool = m.next;`，很明显可以看出来，这是一个链表结构。`sPool`指向当前message，`next`指向下一个message。  
在解释这段代码前，需要先明确两点：`sPool`声明为`private static Message sPool;`；`next`声明为`/*package*/ Message next;`。即前者为该类所有示例共享，后者则每个实例都有。  
现在为了便于理解，我们将`Message`抽象为C语言中的链表节点结构体，指针域便是用于指向下一个消息的`next`字段，其他则都视为数据域。  
假设该链表初始状态如下  
![初始状态][20160713203707125]  
执行`Message m = sPool;`就变成下图  
![Message m = sPool][Message m _ sPool]  
继续`sPool = m.next;`  
![sPool = m.next][sPool _ m.next]  
然后`m.next = null;`  
![m.next = null][m.next _ null]  
接下来`m.flags=0;sPoolSize--;return m;`便是表示m指向的对象已经从链表中取出并返回了。

## 回收recycle() ##

然后再看看`sPoolSize`是什么时候自增的。按图索骥便可找到`recycle()`方法和`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) {
            if (sPoolSize < MAX_POOL_SIZE) {
                next = sPool;
                sPool = this;
                sPoolSize++;
            }
        }
    }
      
       
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23

前半段不必多说，显然是“重置”改对象的个个字段。后半段又是一个同步代码段，同样用图来解释一下（假设当前代码为`message.recycle()`，则需要被回收的则是`message`对象）。  
假设当前链表如下：  
![初始状态][20160713204015503]  
执行`next=sPool;`  
![next=sPool][next_sPool]  
执行`sPool=this`;  
![sPool=this][sPool_this]  
现在可以很清楚的看到，Message类本身就组织了一个栈结构的缓冲池。并使用`obtain()`方法和`recycler()`方法来取出和放入。

[20160713203707125]: /images/20220523/b07ba89423e347649bacda5a0801e0f7.png
[Message m _ sPool]: /images/20220523/e8eb9cfb7d474ca99af3b104ad3c45e9.png
[sPool _ m.next]: /images/20220523/9a9f0683487a4183b0c5192fdc577ba1.png
[m.next _ null]: /images/20220523/019c836536b04b8db5f3786e14b70adb.png
[20160713204015503]: /images/20220523/da45a5fcfe504fafbd90a70affabfb62.png
[next_sPool]: /images/20220523/99628daab31444e49499ee943f40729d.png
[sPool_this]: /images/20220523/d44ad094727d4b1680b29c08c73b4828.png