七分钟读懂 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,最后查找其他 Pshared,如果以上全部没有可用元素,最后会调用 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 时定义了 poolNew 函数:

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

图片描述


Go语言源码分析
Go 语言、库、框架源码阅读与分析。【欢迎投稿】

undefined

520 声望
30 粉丝
0 条评论
推荐阅读
Shell 快速上手
引言 Shell 是 linux 系统下非常实用的工具。通过使用 Shell,可以提升在 linux 系统下的工作效率。 Shell 学习 代码都在这里:[链接] 变量 {代码...} 转义和引用 {代码...} 运算符 {代码...} 特殊字符 {代码...}...

Y_xx1阅读 1.5k

数据结构与算法:二分查找
一、常见数据结构简单数据结构(必须理解和掌握)有序数据结构:栈、队列、链表。有序数据结构省空间(储存空间小)无序数据结构:集合、字典、散列表,无序数据结构省时间(读取时间快)复杂数据结构树、 堆图二...

白鲸鱼9阅读 6.5k

「刷起来」Go必看的进阶面试题详解
逃逸分析是Go语言中的一项重要优化技术,可以帮助程序减少内存分配和垃圾回收的开销,从而提高程序的性能。下面是一道涉及逃逸分析的面试题及其详解。

王中阳Go4阅读 1.9k评论 1

封面图
初学后端,如何做好表结构设计?
这篇文章介绍了设计数据库表结构应该考虑的4个方面,还有优雅设计的6个原则,举了一个例子分享了我的设计思路,为了提高性能我们也要从多方面考虑缓存问题。

王中阳Go4阅读 1.7k评论 2

封面图
滚蛋吧,正则表达式!
你是不是也有这样的操作,比如你需要使用「电子邮箱正则表达式」,首先想到的就是直接百度上搜索一个,然后采用 CV 大法神奇地接入到你的代码中?

良许4阅读 2.2k

又一款眼前一亮的Linux终端工具!
今天给大家介绍一款最近发现的功能十分强大,颜值非常高的一款终端工具。这个神器我是在其他公众号文章上看到的,但他们都没把它的强大之处介绍明白,所以我自己体验一波后,再向大家分享自己的体验。

良许5阅读 1.8k

一分钟搞明白!快速掌握 Go WebAssembly
最近因为各种奇怪的原因,更多的接触到了 WebAssembly。虽然之前很多博客也翻过写过各种文章,但总感觉欠些味道。于是今天梳理了一版,和大家一起展开学习。

煎鱼4阅读 2.1k

undefined

520 声望
30 粉丝
宣传栏