分分钟读懂Go的临时对象池pool及其应用场景

edu83

临时对象池 pool 是啥？sync.Pool 给了一大段注释来说明 pool 是啥，我们看看这段都说了些什么。
临时对象池是一些可以分别存储和取出的临时对象。
池中的对象会在没有任何通知的情况下被移出（释放或者重新取出使用）。如果 pool 中持有某个对象的唯一引用，则该对象很可能会被回收。
Pool 在多 goroutine 使用环境中是安全的。
Pool 是用来缓存已经申请了的 目前未使用的 接下来可能会使用的 内存，以此缓解 GC 压力。使用它可以方便高效的构建线程安全的 free list（一种用于动态内存申请的数据结构）。然而，它并不适合所有场景的 free list。
在同一 package 中独立运行的多个独立线程之间静默共享一组临时元素才是 pool 的合理使用场景。Pool 提供在多个独立 client 之间共享临时元素的机制。
在 fmt 包中有一个使用 Pool 的例子，它维护了一个动态大小的输出 buffer。
另外，一些短生命周期的对象不适合使用 pool 来维护，这种情况下使用 pool 不划算。这是应该使用它们自己的 free list（这里可能指的是 go 内存模型中用于缓存 <32k小对象的 free list） 更高效。
Pool 一旦使用，不能被复制。
Pool 结构体的定义为：

1. type Pool struct {
   
2.    noCopy noCopy
   
3. 
   
4.    local     unsafe.Pointer // 本地P缓存池指针
   
5.    localSize uintptr        // 本地P缓存池大小
   
6. 
   
7.    // 当池中没有可能对象时
   
8.    // 会调用 New 函数构造构造一个对象
   
9.    New func() interface{}
   
10. }

复制代码

Pool 中有两个定义的公共方法，分别是 Put - 向池中添加元素；Get - 从池中获取元素，如果没有，则调用 New 生成元素，如果 New 未设置，则返回 nil。
Pool 会为每个 P 维护一个本地池，P 的本地池分为 私有池 private 和共享池 shared。私有池中的元素只能本地 P 使用，共享池中的元素可能会被其他 P 偷走，所以使用私有池 private 时不用加锁，而使用共享池 shared 时需加锁。
Get 会优先查找本地 private，再查找本地 shared，最后查找其他 P 的 shared，如果以上全部没有可用元素，最后会调用 New 函数获取新元素。

1. func (p *Pool) Get() interface{} {
   
2.    if race.Enabled {
   
3.       race.Disable()
   
4.    }
   
5.    // 获取本地 P 的 poolLocal 对象
   
6.    l := p.pin()
   
7.    
   
8.    // 先获取 private 池中的对象（只有一个）
   
9.    x := l.private
   
10.    l.private = nil
    
11.    runtime_procUnpin()
    
12.    if x == nil {
    
13.       // 查找本地 shared 池，
    
14.       // 本地 shared 可能会被其他 P 访问
    
15.       // 需要加锁
    
16.       l.Lock()
    
17.       last := len(l.shared) - 1
    
18.       if last >= 0 {
    
19.          x = l.shared[last]
    
20.          l.shared = l.shared[:last]
    
21.       }
    
22.       l.Unlock()
    
23.       
    
24.       // 查找其他 P 的 shared 池
    
25.       if x == nil {
    
26.          x = p.getSlow()
    
27.       }
    
28.    }
    
29.    if race.Enabled {
    
30.       race.Enable()
    
31.       if x != nil {
    
32.          race.Acquire(poolRaceAddr(x))
    
33.       }
    
34.    }
    
35.    // 未找到可用元素，调用 New 生成
    
36.    if x == nil && p.New != nil {
    
37.       x = p.New()
    
38.    }
    
39.    return x
    
40. }

复制代码

getSlow，从其他 P 中的 shared 池中获取可用元素：

1. func (p *Pool) getSlow() (x interface{}) {
   
2.    // See the comment in pin regarding ordering of the loads.
   
3.    size := atomic.LoadUintptr(&p.localSize) // load-acquire
   
4.    local := p.local                         // load-consume
   
5.    // Try to steal one element from other procs.
   
6.    pid := runtime_procPin()
   
7.    runtime_procUnpin()
   
8.    for i := 0; i < int(size); i++ {
   
9.       l := indexLocal(local, (pid+i+1)%int(size))
   
10.       // 对应 pool 需加锁
    
11.       l.Lock()
    
12.       last := len(l.shared) - 1
    
13.       if last >= 0 {
    
14.          x = l.shared[last]
    
15.          l.shared = l.shared[:last]
    
16.          l.Unlock()
    
17.          break
    
18.       }
    
19.       l.Unlock()
    
20.    }
    
21.    return x
    
22. }

复制代码

Put 优先把元素放在 private 池中；如果 private 不为空，则放在 shared 池中。有趣的是，在入池之前，该元素有 1/4 可能被丢掉。

1. func (p *Pool) Put(x interface{}) {
   
2.    if x == nil {
   
3.       return
   
4.    }
   
5.    if race.Enabled {
   
6.       if fastrand()%4 == 0 {
   
7.          // 随机把元素扔掉...
   
8.          // Randomly drop x on floor.
   
9.          return
   
10.       }
    
11.       race.ReleaseMerge(poolRaceAddr(x))
    
12.       race.Disable()
    
13.    }
    
14.    l := p.pin()
    
15.    if l.private == nil {
    
16.       l.private = x
    
17.       x = nil
    
18.    }
    
19.    runtime_procUnpin()
    
20.    if x != nil {
    
21.       // 共享池访问，需要加锁
    
22.       l.Lock()
    
23.       l.shared = append(l.shared, x)
    
24.       l.Unlock()
    
25.    }
    
26.    if race.Enabled {
    
27.       race.Enable()
    
28.    }
    
29. }

复制代码

当世界暂停，垃圾回收将要开始时， poolCleanup 会被调用。该函数内不能分配内存且不能调用任何运行时函数。原因：防止错误的保留整个 Pool如果 GC 发生时，某个 goroutine 正在访问 l.shared，整个 Pool 将会保留，下次执行时将会有双倍内存

1. func poolCleanup() {  
   
2.    for i, p := range allPools {
   
3.       allPools[i] = nil
   
4.       for i := 0; i < int(p.localSize); i++ {
   
5.          l := indexLocal(p.local, i)
   
6.          l.private = nil
   
7.          for j := range l.shared {
   
8.             l.shared[j] = nil
   
9.          }
   
10.          l.shared = nil
    
11.       }
    
12.       p.local = nil
    
13.       p.localSize = 0
    
14.    }
    
15.    allPools = []*Pool{}
    
16. }

复制代码