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

临时对象池 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 结构体的定义为：

type pool struct {
 nocopy nocopy

 local  unsafe.pointer // 本地p缓存池指针
 localsize uintptr  // 本地p缓存池大小

 // 当池中没有可能对象时
 // 会调用 new 函数构造构造一个对象
 new func() interface{}
}

pool 中有两个定义的公共方法，分别是 put - 向池中添加元素；get - 从池中获取元素，如果没有，则调用 new 生成元素，如果 new 未设置，则返回 nil。

get

pool 会为每个 p 维护一个本地池，p 的本地池分为 私有池 private 和共享池 shared。私有池中的元素只能本地 p 使用，共享池中的元素可能会被其他 p 偷走，所以使用私有池 private 时不用加锁，而使用共享池 shared 时需加锁。

get 会优先查找本地 private，再查找本地 shared，最后查找其他 p 的 shared，如果以上全部没有可用元素，最后会调用 new 函数获取新元素。

func (p *pool) get() interface{} {
 if race.enabled {
  race.disable()
 }
 // 获取本地 p 的 poollocal 对象
 l := p.pin() 
 
 // 先获取 private 池中的对象（只有一个）
 x := l.private
 l.private = nil
 runtime_procunpin()
 if x == nil {
  // 查找本地 shared 池，
  // 本地 shared 可能会被其他 p 访问
  // 需要加锁
  l.lock()
  last := len(l.shared) - 1
  if last >= 0 {
   x = l.shared[last]
   l.shared = l.shared[:last]
  }
  l.unlock()
  
  // 查找其他 p 的 shared 池
  if x == nil {
   x = p.getslow()
  }
 }
 if race.enabled {
  race.enable()
  if x != nil {
   race.acquire(poolraceaddr(x))
  }
 }
 // 未找到可用元素，调用 new 生成
 if x == nil && p.new != nil {
  x = p.new()
 }
 return x
}

getslow，从其他 p 中的 shared 池中获取可用元素：

func (p *pool) getslow() (x interface{}) {
 // see the comment in pin regarding ordering of the loads.
 size := atomic.loaduintptr(&p.localsize) // load-acquire
 local := p.local       // load-consume
 // try to steal one element from other procs.
 pid := runtime_procpin()
 runtime_procunpin()
 for i := 0; i < int(size); i++ {
  l := indexlocal(local, (pid+i+1)%int(size))
  // 对应 pool 需加锁
  l.lock()
  last := len(l.shared) - 1
  if last >= 0 {
   x = l.shared[last]
   l.shared = l.shared[:last]
   l.unlock()
   break
  }
  l.unlock()
 }
 return x
}

put

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

func (p *pool) put(x interface{}) {
 if x == nil {
  return
 }
 if race.enabled {
  if fastrand()%4 == 0 {
   // 随机把元素扔掉...
   // randomly drop x on floor.
   return
  }
  race.releasemerge(poolraceaddr(x))
  race.disable()
 }
 l := p.pin()
 if l.private == nil {
  l.private = x
  x = nil
 }
 runtime_procunpin()
 if x != nil {
  // 共享池访问，需要加锁
  l.lock()
  l.shared = append(l.shared, x)
  l.unlock()
 }
 if race.enabled {
  race.enable()
 }
}

poolcleanup

当世界暂停，垃圾回收将要开始时， poolcleanup 会被调用。该函数内不能分配内存且不能调用任何运行时函数。原因：
防止错误的保留整个 pool

如果 gc 发生时，某个 goroutine 正在访问 l.shared，整个 pool 将会保留，下次执行时将会有双倍内存

func poolcleanup() { 
 for i, p := range allpools {
  allpools[i] = nil
  for i := 0; i < int(p.localsize); i++ {
   l := indexlocal(p.local, i)
   l.private = nil
   for j := range l.shared {
   l.shared[j] = nil
   }
   l.shared = nil
  }
  p.local = nil
  p.localsize = 0
 }
 allpools = []*pool{}
}

案例1：gin 中的 context pool

在 web 应用中，后台在处理用户的每条请求时都会为当前请求创建一个上下文环境 context，用于存储请求信息及相应信息等。context 满足长生命周期的特点，且用户请求也是属于并发环境，所以对于线程安全的 pool 非常适合用来维护 context 的临时对象池。

gin 在结构体 engine 中定义了一个 pool:

type engine struct {
 // ... 省略了其他字段
 pool    sync.pool
}

初始化 engine 时定义了 pool 的 new 函数：

engine.pool.new = func() interface{} {
 return engine.allocatecontext()
}

// allocatecontext
func (engine *engine) allocatecontext() *context {
 // 构造新的上下文对象
 return &context{engine: engine}
}

servehttp:

// 从 pool 中获取，并转化为 *context
c := engine.pool.get().(*context)
c.writermem.reset(w)
c.request = req
c.reset() // reset

engine.handlehttprequest(c)

// 再扔回 pool 中
engine.pool.put(c)

案例2：fmt 中的 printer pool

printer 也符合长生命周期的特点，同时也会可能会在多 goroutine 中使用，所以也适合使用 pool 来维护。

printer 与 它的临时对象池

// pp 用来维护 printer 的状态
// 它通过 sync.pool 来重用，避免申请内存
type pp struct {
 //... 字段已省略
}

var ppfree = sync.pool{
 new: func() interface{} { return new(pp) },
}

获取与释放：

func newprinter() *pp {
 p := ppfree.get().(*pp)
 p.panicking = false
 p.erroring = false
 p.fmt.init(&p.buf)
 return p
}

func (p *pp) free() {
 p.buf = p.buf[:0]
 p.arg = nil
 p.value = reflect.value{}
 ppfree.put(p)
}

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对的支持。