syncpool的实现原理

**题目序号：**361

题目来源：

**频次：**1

答案1：（趁醉独饮痛）

Pool是什么：

Go标准库中提供的一个通用的Pool数据结构，可以使用它创建池化的对象。sync.Pool数据类型的对象用来保存一组可独立访问的临时对象，注意它是临时的，也就是说sync.Pool中保存的对象会在将来的某个时间从sync.Pool中移除掉，如果也没有被其他对象引用的话，该对象会被垃圾回收掉。

Go是一个自带GC的语言，使用起来没有心智负担，我们想使用一个对象就创建一个对象，想使用多个就创建多个，不用关心对象的释放问题。因为有GC程序会帮助我们自动将不再使用的对象的内存回收掉。但是在使用Go开发高性能的应用程序的时候，需要考虑GC执行垃圾回收给我们带来的影响。在GC执行垃圾回收的过程中需要STW(stop-the-world)时间，如果创建有大量的对象，GC程序在检查这些对象是不是垃圾的时候需要花费很多时间。进而对业务功能造成性能影响。

优点：

• 减轻GC负担
• 减少新对象的申请 复用对象，避免每次使用对象都要创建对象

1. sync.Pool 本身就是线程安全的，多个 goroutine 可以并发地调用它的方法存取对象；
2. sync.Pool 不可在使用之后再复制使用（struct 中有 Nocopy 静态检查是否复制使用）

三个方法：

**New：**当调用 Pool 的 Get方法从池中获取元素，

        1. 没有更多的空闲元素可返回时，就会调用这个 New 方法来创建新的元素。
        2. 没有设置 New 字段，没有更多的空闲元素可返回时，Get 方法将返回 nil，表明当前没有可用的元素。
        3. **Get：从Pool 移除一个元素，这个元素会从 Pool 中移除，返回给调用者，返回值可能是 nil**

Put：将一个元素返还给 Pool，Pool 会把这个元素保存到池中，并且可以复用。但如果 Put 一个 nil 值，Pool 就会忽略这个值

原理：

(sync.Pool结构图)

1.13< 版本之前的两个问题：

• 每次 GC 都会回收创建的对象。
  1. 元素过多会导致 SWT 耗时变长
  2. 缓存元素都被回收后，会导致Get 命中率下降，不得不创建心的对象
• 底层实现使用了 Mutex，对这个锁并发请求竞争激烈的时候，会导致性能的下降。
  1. Go 对 Pool 的优化就是避免使用锁，同时将加锁的 queue 改成 lock-free 的 queue 的实现，给即将移除的元素再多一次“复活”的机会。

Pool 最重要的两个字段 （local 和 victim）

1. local：

local是一个poolLocal数组的指针，localSize代表这个数组的大小，它的大小是goroutine中P的数量。每个P都有一个ID,这个ID的值对应着poolLoca数组的下标索引。所以poolLocal数组大小最大为runtime.GOMAXPROCS(0)。victim对应local,它也是一个poolLocal数组的指针，victimSize是victim数组的大小。每次垃圾回收的时候，Pool会把victim中的对象清理掉，然后把local的数据赋值给victim，并把local设置为nil,victim像一个中转站，里面的数据可以被捡回来重新使用，也可能被GC回收掉。

1. Victim:

victim 中的元素如果被 Get 取走，那么这个元素就很幸运，因为它又“活”过来了。但是，如果这个时候 Get 的并发不是很大，元素没有被 Get 取走，那么就会被移除掉，因为没有别人引用它的话，就会被垃圾回收掉。

type Pool struct {
 noCopy noCopy
 // local是一个指向[p]poolLocal的指针，它指向的是一个数组，此数组中的元素是poolLocal类型
 // 数组的大小是固定的，数量与p的数量是相同的，也是每个p对应数组中的1个元素
 local unsafe.Pointer 
 // local数组的大小
 localSize uintptr 
 // victim类型与local是一样的，可以理解为local的中转站，过渡存储local用的
 victim unsafe.Pointer 
 // victim数组的大小
 victimSize uintptr 
 // New方法，返回的空接口类型，该字段也是Pool唯一暴露给外界的字段
 // New方法可以赋值一个能够产生值的函数，在调用Get方法的时候可以用
 // New方法来产生一个value，如果没有给New赋值，调用Get时将返回nil.
 New func() interface{}
}

poolLocal：

poolLocal是sync.Pool中local或victim指向数组中的元素类型，里面有一个pad数组填充，使得poolLocal的大小构成128字节的整数倍，是为了防止在cache line上分配多个poolLocalInternal从而造成伪共享。

type poolLocal struct {
 poolLocalInternal
 // pad是填充用的，防止伪共享，让整个poolLocal构成128字节的整数倍
 pad [128 - unsafe.Sizeof(poolLocalInternal{})%128]byte
}

poolLocalInternal：

它包含private和shared两个字段，private是一个私有对象，只能被拥有它的P使用，而一个P同时只能执行一个G, 所以G访问private不需要加锁，不存在并发冲突。shared是一个双端队列，它既能被与之绑定的P访问和修改，也能被其他的P访问和修改，绑定的P可以从队头加入和出队元素，其他的P只能从队尾出队元素

// poolLocal的内部结构，Pool中的poolLocal是对poolLocalInternal的简单包装
type poolLocalInternal struct {
 // private是一个私有对象，从名字可以看出来，它只能被拥有它的P使用
 // Pool中也说明了，每个P有1个poolLocal，也即有一个poolLocalInternal
 // 这里的private只能被他属于的P使用
 private interface{} // Can be used only by the respective P.
 // shared是一个双端队列，它既能被与之绑定的P访问和修改，也能被其他的P访问和修改
 // 绑定的P可以从对头入队加和出队元素，其他的P只能从队尾出队元素。
 shared poolChain 
}

poolChain：

poolChain是一个双向链表的结构体头，它保存着双向链表的头节点和尾节点指针，链表中节点元素类型是poolChainElt。这里需要注意一下，按照我们常规数据结构的理解，head指针指向的位置在链表最左边，tail指针指向的位置在最右边，但是这里刚好是相反的，这里的head指针指向链表的最右边，tail指向最左边。每添加一个元素的时候，添加在head节点的下一个节点，然后将head指向刚添加的节点。

// poolChain是一个双向链表的结构体头，它保存着双向链表的头节点和尾节点指针，poolChainElt
// 是链表中每个节点的类型结构，该结构类型中有2个字段，headTail uint64和 vals []eface，
// headTail作用后面有描述，vals就是存储元素的切片。vals的大小在每个poolChainElt是不同的，
// 相邻的2个直接大小存在着2倍的关系。
type poolChain struct {
 // head只会被1个生产者调用，即Put操作，只在头部添加元素，不需要强同步
 head *poolChainElt
 // tail被消费者调用，从尾部获取元素，可能有多个消费者同时获取，所以操作必须是原子的
 tail *poolChainElt
}

poolChainElt：

双向链表中的节点结构，它有一个存储数据的poolDequeue队列，next和prev分别是指向前后节点的指针。poolDequeue中vals字段存放元素，vals是一个固定大小的切片，相邻的两个poolChainElt中的vals大小存在2倍关系，第一个poolChainElt中vals大小是8，可以结合上面pool结构图看，第二个poolChainElt中的size是16，最大值为2^30。

type poolChainElt struct {
 // 存数据的队列，是一个固定大小的切片
 poolDequeue
 // next和prev是双向链表的指针，next被生产者写，消费者读，它的值只会从
 // nil变成非nil, prev被消费者写，生产者读，它的值只会从非nil变成nil
 next, prev *poolChainElt
}

poolDequeue：

poolDequeue是一个无锁的、固定大小的，单个生产者、多个消费者的队列。poolDequeue无锁实现是Pool的精髓，巧妙采用CAS去掉了1.13版本之前的有锁实现。它有headTail和vals两个字段，headTail占8个字节，高4字节表示的是head在vals中的下标位置，低4字节表示的是tail在vals中的下标位置。生产者每生产1个数据，head+1，消费者每取走队列中1个数据，tail+1.当tail与head相等的时候，说明队列中没有元素了，当tail+len(vals)=head的时候，说明队列满了。

// poolDequeue是一个无锁的、固定大小的、单个生产者、多个消费者的队列
// 生产者只能从队头向队列添加数据或者从队头取走数据，单个或多个消费者可以
// 可用队尾取走数据
type poolDequeue struct {
 // headTail占8个字节，分为两部分，高位4字节和低位4字节，高4字节表示的
 // 32位int数据描述的是head下标，低4字节表示的是32位int数据描述的是tail
 // 下标，这里的下标说的都是下面vals数组的下标，vals[tail,head)下标范围
 // 内是有数据的，可以被消费者消费。生产者每生产1个数据，head会+1， 消费者
 // 每取走队列中1个数据，tail+1, 当tail赶上head的时候，说明队列中没有数
 // 据了,头部索引存储在最高有效位中，因此我们可以原子地添加它，溢出并不会产生
 // 别的影响。
 headTail uint64
 // vals是一个存储数据的环形队列，数据可以是任何类型，因为定义的类型是interface{}
 // 它的大小必须是2整数次幂。vals[i].typ为nil,表示该下标位置的没有放数据，typ不是
 // nil表示该位置已放有数据。在tail还未设置为i+1和vals[i].typ为非nil前，vals中的
 // 位置i视为还在占用状态。当前消费者取走数据或是生产者读取走数据后，vals[i]将自动被
 // 它们设置为nil.
 vals []eface
}
type eface struct {
 typ, val unsafe.Pointer
}

Get实现原理:

Get先从本地 local 的private中获取元素，此private只能被当前的P访问,一个P同时只能运行一个G， 所以直接访问l.privated不需要加锁。如果local.private中没有元素了，尝试从local.shared队列的头部弹出一个元素，如果local.shared中也没有元素了，则从其他P对应的shared中偷取一个，如果其他P对应的shared中也没有元素了，再检查victim中是否有元素，如果还是没有，设置了New方法，将调用New方法产生一个。如果没有设置New方法，将返回nil。

// Get方法从Pool中返回一个元素，并将它从Pool中移除，调用者不要假定放入（Put方法）Pool中元素和从里面
// 取（Get）出来的元素有任何关系,如果Pool中没有缓存的元素了并且P.New没有赋值将会返回nil.否则调用New
// 方法产生一个对象返回
func (p *Pool) Get() interface{} {
 if race.Enabled {
  race.Disable()
 }
 // 把当前的goroutine固定在当前的P上，返回当前的P上的*poolLocal
 l, pid := p.pin()
 // 先从本地local的private字段获取元素，此private只能被当前的P访问
 // 其他P是不能访问的，一个P同一时间只能有1个goroutine在运行，所以
 // 直接访问l.private并不需要加锁
 x := l.private
 l.private = nil
 // private中没有元素
 if x == nil {
  // 尝试从当前的本地local.shared中出队一个元素，x是从队头弹出的。
  x, _ = l.shared.popHead()
  if x == nil {
   // 如果从local.shared也没有拿到，则从其他P中的l.shared中偷1个
            // 如果shared中也没有，产生从victim中获取
   x = p.getSlow(pid)
  }
 }
 runtime_procUnpin()
 if race.Enabled {
  race.Enable()
  if x != nil {
   race.Acquire(poolRaceAddr(x))
  }
 }
 // 走到这里说明，private, local.shared, 其他P中的local.shared, 本地local.victim，
 // 其他P中的local.victim都没有缓存了，如果设置New函数，调用New函数创建一个元素返回
 if x == nil && p.New != nil {
  x = p.New()
 }
 // 走到这里说明没有设置New函数，返回nil
 retur

pin方法会调用 runtime_procPin 方法获取当前运行的G绑定到当前的P上，禁止抢占，返回关联P的pid. 然后原子操作取出p.localSize值与Pid进行比较，正常情况下pid是不会比localSize 大，如果不在 ocalSize 范围内，说明程序修改过P的大小，会走到pinSlow处理逻辑。
pin方法会调用runtime_procPin方法获取当前运行的G绑定到当前的P上，禁止抢占，返回关联P的pid. 然后原子操作取出p.localSize值与Pid进行比较，正常情况下pid是不会比localSize大，如果不在localSize范围内，说明程序修改过P的大小，会走到pinSlow处理逻辑。

// 将当前的G定在与它关联的P上，禁止抢占，返回关联P对应的poolLocal对象和P的id
// 调用者必须执行runtime_procUnpin操作当结束对pool操作的时候
func (p *Pool) pin() (*poolLocal, int) {
 // 获取运行当前G,与之关联的P的id
 pid := runtime_procPin()
 // 检查localSize是不是比pid大，正常情况下p.localSize=max(pid)+1
 // 因为pid是P的id,如果P的数量为n,则pid的范围为[0,n), 如果pid的值不在
 // localSize范围内，说明程序修改过P的数量，这里就会走到pinSlow逻辑
 // pinSlow逻辑主要是重新分配p的local和localSize
 s := atomic.LoadUintptr(&p.localSize) // load-acquire
 l := p.local                          // load-consume
 if uintptr(pid) < s {
  return indexLocal(l, pid), pid
 }
 return p.pinSlow()
}

pinSlow会再次检查pid是否在localSize范围内，如果不在，将会重新分配poolLocal数组给local, 初始化localSize大小，并将p加入到全局的allPools切片中，allPools维护了程序中所有的sync.Pool对象。

func (p *Pool) pinSlow() (*poolLocal, int) {
 runtime_procUnpin()
 allPoolsMu.Lock()
 defer allPoolsMu.Unlock()
 pid := runtime_procPin()
 // 已经加了allPoolsMu全局锁，这里可以直接读取localSize和local，不存在data race
 s := p.localSize
 l := p.local
 // 再次判断pid的值是否在正常的范围内，刚才前面解除了禁止抢占，等现在再拿到pid的时候
 // 可能不是之前的pid了
 if uintptr(pid) < s {
  return indexLocal(l, pid), pid
 }
 // 将p加入到全局pool allPools中
 if p.local == nil {
  allPools = append(allPools, p)
 }
 // GOMAXPROCS传0返回值是当前可以并发运行的CPU数
 size := runtime.GOMAXPROCS(0)
 // 创建一个新的poolLocal切片，并复制给当前的p
 local := make([]poolLocal, size)
 atomic.StorePointer(&p.local, unsafe.Pointer(&local[0])) // store-release
 atomic.StoreUintptr(&p.localSize, uintptr(size))         // store-release
 // 返回当前的P对应的localPool和pid的值
 return &local[pid], pid
}
// l存储的是local的起始地址，local是一个poolLocal数组，所以根据起始位置+poolLocal的偏移量
// 可以获取到第i个索引中的poolLocal值
func indexLocal(l unsafe.Pointer, i int) *poolLocal {
 lp := unsafe.Pointer(uintptr(l) + uintptr(i)*unsafe.Sizeof(poolLocal{}))
 return (*poolLocal)(lp)
}

分析Get中的popHead操作，popHead从poolChain中获取一个数据，优先从头节点head指向的环形队列中获取，如果没有获取到，再从head前一个节点指向的环形队列中获取，直到查询完所有的队列都没有，返回失败。整个处理过程是不断的从链表的head节点向尾节点遍历，对遍历到的每个节点执行popHead, 这个节点类型是poolDequeue, poolDequeue的popHead。

// popHead从poolChain获取一个数据，优先从头部的环形队列中获取，
// 如果没有获取到，在从head前一个节点指向的环形队列中获取，直到
// 查询完所有的队列都没有，返回获取失败false
func (c *poolChain) popHead() (interface{}, bool) {
 d := c.head
 // 从head节点开始查找
 for d != nil {
  if val, ok := d.popHead(); ok {
   return val, ok
  }
  // 继续查找前一个队列，只要d非空即没有查到tail位置，一直
  // 查找，获取到了数据就提前返回
  d = loadPoolChainElt(&d.prev)
 }
 // 走到这里表示没有获取数据，返回失败
 return nil, false
}
// popHead从队列的头部返回一个元素，如果队列为空，第2个返回值将返回false, 注意该函数
// 只能被单个生产者调用，多个生产者即G同时调用，会引发数据竞争
func (d *poolDequeue) popHead() (interface{}, bool) {
 var slot *eface
 for {
  ptrs := atomic.LoadUint64(&d.headTail)
  head, tail := d.unpack(ptrs)
  // 下标tail和head相等了，说明tail追赶上了head,即将vals中的元素取完了
  if tail == head {
   // Queue is empty.
   return nil, false
  }
  head--
  // 构建一个新的uint64,head是-1后的值
  ptrs2 := d.pack(head, tail)
  // 进一步比较headTail和ptrs，如果相同说明没有修改它，将其设置为ptrs2
  // 这时可以放心大胆的对head进行操作，获取里面的元素了，如果这段时间headTail
  // 有人修改，继续进行下一轮循环处理
  if atomic.CompareAndSwapUint64(&d.headTail, ptrs, ptrs2) {
   // 这里可以放心大胆的读取vals中head下标处的元素了
   slot = &d.vals[head&uint32(len(d.vals)-1)]
   break
  }
 }
 // 这里判断slot中的val是不是dequeueNil型，因为在pushHead中有肯能会放入，作占位用
 val := *(*interface{})(unsafe.Pointer(slot))
 if val == dequeueNil(nil) {
  val = nil
 }
 // 将slot填充为nil值，因为popHead和pushHead不会同时被调用，所以这里可以放心大胆对其进行
 // 操作，还有一点是，前面已经重新设置了head值了，popTail已经不可能访问到slot这里，也不用担心
 // popTail与popHead在这里的冲突问题
 *slot = eface{}
 return val, true
}

如果shared中的popHead方法也没有获取到值，将会调下面的getSlow方法。先尝试从其他的P对应的poolLocal中偷一个元素，尝试的顺序是从当前pid+1个索引位置开始的，会对sync.local检查一圈。对每个poolLocal检查的是shared中的元素，看尾部有没有元素，如果有从尾部弹出一个元素。如果检查完所有的poolLocal中的shared都没有找到，接下来将在当前本地poolLocal中的victim的private查找，如果还是没有，就检查它的victim的shared是否有，最后检查其他P对应的poolLocal中victim中的shared是否有数据。

func (p *Pool) getSlow(pid int) interface{} {
 // See the comment in pin regarding ordering of the loads.
 size := atomic.LoadUintptr(&p.localSize) // load-acquire
 locals := p.local                        // load-consume
 // Try to steal one element from other procs.
 // 尝试从其他P中偷一个元素，尝试P的顺序是从当前pid+1个索引位置开始对应的
 // poolLocal中的shared开始查找是否有元素，在shared中的查询方式是从
 // 它的尾部弹出一个元素，如果shared队列中没有，继续尝试下一个位置，直到
 // 循环检查一圈都没有，走victim中检查
 for i := 0; i < int(size); i++ {
  l := indexLocal(locals, (pid+i+1)%int(size))
  if x, _ := l.shared.popTail(); x != nil {
   return x
  }
 }
 size = atomic.LoadUintptr(&p.victimSize)
 if uintptr(pid) >= size {
  return nil
 }
 // 下面尝试从受害中缓存victim中查找是否元素，查找的位置是从pid索引位置开始的poolLocal
 // 产生从它的shared尾部弹出一个元素，如果有就返回，如果没有就尝试下一个位置的poolLocal
 locals = p.victim
 l := indexLocal(locals, pid)
 // 检查victim.private是否有元素，有就返回
 if x := l.private; x != nil {
  l.private = nil
  return x
 }
 for i := 0; i < int(size); i++ {
  l := indexLocal(locals, (pid+i)%int(size))
  if x, _ := l.shared.popTail(); x != nil {
   return x
  }
 }
 // 这里将p.victimSize设置为0，是为了减少后序调用getSlow,不用再一次遍历
 // victim数组了，直接返回nil, 加快处理速度
 atomic.StoreUintptr(&p.victimSize, 0)
 // 尝试了所有的local.shared和victim.private, victim.shared都没有找到，返回nil
 return nil
}
// popTail从poolChain中获取一个数据返回，第一个返回值表示返回的数据，第二个
// 返回值表示是否成功获取到了数据，如果没有获取到，将返回false
func (c *poolChain) popTail() (interface{}, bool) {
 d := loadPoolChainElt(&c.tail)
 // d为nil,表示c.tail还未初始化，比如第一次执行Get操作的时候就会发生，这个时候
 // 还没有Put数据进去，所以获取失败
 if d == nil {
  return nil, false
 }
 for {
  // 需要注意这里先要进行loadPoolChainElt操作再执行d.popTail操作，
  // 这两条语句不能颠倒顺序，一般来说，d可能短暂为空，如果在执行pop
  // 且执行失败了，但是在执行前d2为非空。这种情况d永久会为空了，需要将
  // d从poolChain中移除掉
  d2 := loadPoolChainElt(&d.next)
  if val, ok := d.popTail(); ok {
   return val, ok
  }
  if d2 == nil {
   // 走完整个链表了，还是没有获取到数据，直接返回nil,false
   return nil, false
  }
  // 当前tail执行的节点中的环形队列中已经没有数据可以获取了，尝试tail的
  // next节点中获取，因为当前的tail节点永远不会再有数据，所以把它从poolChain
  // 移除掉，下次再执行popTail的时候，就不用检查这个空队列了。
  // 这里采用了CAS操作，因为有多个消费者可能并行执行popTail.
  if atomic.CompareAndSwapPointer((*unsafe.Pointer)(unsafe.Pointer(&c.tail)), unsafe.Pointer(d), unsafe.Pointer(d2)) {
   // 将d从poolChain中移除，以便在gc的时候可以将d回收掉，
   // 那为啥在上面的popHead中没有将d从poolChain中移除掉呢？
   // 因为popHead中的d可以留着，在后序的pushHead中可以继续
   // 使用，而popTail中的d永远不会再被使用了，因为没有pushTail操作
   storePoolChainElt(&d2.prev, nil)
  }
  d = d2
 }
}

上面的popTail对d的处理做了优化，将d从poolChain中移除，以便在gc的时候可以将d回收掉，那为啥在上面的popHead中没有将d从poolChain中移除掉呢？因为popHead中的d可以留着，在后序的pushHead中可以继续使用，而popTail中d永远不会再被使用了，因为没有pushTail操作。

Put实现原理

Put操作处理逻辑比较简单，优先将元素放在本地的private,如果private字段已经有值了，会将元素添加到本地的shared队列中。

GC操作：

sync.Pool中的对象并不是一直保持不释放的。否则对象太多了，会引起内存溢出。Go中的GC对sync.Pool做了专门的处理。在pool.go的init函数里，向GC注册了清理机制，源码如下.poolCleanup 会在 STW 阶段被调用。主要是将 local 和 victim 作交换，那么不至于GC 把所有的 Pool 都清空了，而是需要两个 GC 周期才会被释放

// 注册pool清理回调，在gc的时候，会调用poolCleanup
func init() {
 runtime_registerPoolCleanup(poolCleanup)
}
// 清理pool函数，对oldPools和allPools的操作都是没有加锁的，因为这里执行的时候
// 已经STW了，不存在竞争
func poolCleanup() {
 // oldPools是一个全局变量，是一个保存*sync.Pool的切片，这些
 // 切片元素都是等待被gc清理的，当执行完下面的循环之后，就被清理了
 for _, p := range oldPools {
  p.victim = nil
  p.victimSize = 0
 }
 // allPools是当前新产生的*sync.Pool元素集合，里面存储的元素跟前面的
 // oldPools是不同的，当该轮gc执行的时候，会将allPools中所有的Pool中的
 // local元素移动到victim受害者缓存中，并将local缓存清空
 for _, p := range allPools {
  p.victim = p.local
  p.victimSize = p.localSize
  p.local = nil
  p.localSize = 0
 }
 // 交换oldPools和allPools，处理的很精炼，为什么要这么做呢？
 // 进程起来，运行过程中申请了sync.Pool创建的变量vp，然后执行gc,此时oldPools是空的
 // allPools是非空的，里面装的是vp, 当该函数被调用的时候，将vp中的元素从local移动到victim
 // 即在第一次gc的时候，vp中的元素没有被垃圾回收，接下来执行下面这个语句之后，allPools被清空
 // oldPools里面保存的是vp, 当下次执行gc的时候，oldPools中的内容被清理掉，所以vp中元素生命
 // 周期在两次gc之间都是存活的
 oldPools, allPools = allPools, nil
}