Golang 语言临时对象池 - sync.Pool

func main () {
 pool := &sync.Pool{
  New: func() interface{} {
   fmt.Println("New 一个新对象")
   return 0
  },
 }
 // 取，临时对象池中没有数据，会调用 New，New 创建一个新对象直接返回，不会存储在临时对象池中
 val := pool.Get().(int)
 fmt.Println(val)
 // 存
 pool.Put(10)
 // 手动调用 GC()，用于验证 GC 之后，临时对象池中的对象会被清空。
 runtime.GC()
 // 取
 val2 := pool.Get().(int)
 fmt.Println(val2)
}

type Pool struct {
 noCopy noCopy
 local     unsafe.Pointer // local fixed-size per-P pool, actual type is [P]poolLocal
 localSize uintptr        // size of the local array
 victim     unsafe.Pointer // local from previous cycle
 victimSize uintptr        // size of victims array
 // New optionally specifies a function to generate
 // a value when Get would otherwise return nil.
 // It may not be changed concurrently with calls to Get.
 New func() interface{}
}

func poolCleanup() {
 // This function is called with the world stopped, at the beginning of a garbage collection.
 // It must not allocate and probably should not call any runtime functions.
 // Because the world is stopped, no pool user can be in a
 // pinned section (in effect, this has all Ps pinned).
 // Drop victim caches from all pools.
 for _, p := range oldPools {
  p.victim = nil
  p.victimSize = 0
 }
 // Move primary cache to victim cache.
 for _, p := range allPools {
  p.victim = p.local
  p.victimSize = p.localSize
  p.local = nil
  p.localSize = 0
 }
 // The pools with non-empty primary caches now have non-empty
 // victim caches and no pools have primary caches.
 oldPools, allPools = allPools, nil
}

// Local per-P Pool appendix.
type poolLocalInternal struct {
 private interface{} // Can be used only by the respective P.
 shared  poolChain   // Local P can pushHead/popHead; any P can popTail.
}
type poolLocal struct {
 poolLocalInternal
 // Prevents false sharing on widespread platforms with
 // 128 mod (cache line size) = 0 .
 pad [128 - unsafe.Sizeof(poolLocalInternal{})%128]byte
}

func (p *Pool) getSlow(pid int) interface{} {
 // See the comment in pin regarding ordering of the loads.
 size := runtime_LoadAcquintptr(&p.localSize) // load-acquire
 locals := p.local                            // load-consume
 // Try to steal one element from other procs.
 for i := 0; i < int(size); i++ {
  l := indexLocal(locals, (pid+i+1)%int(size))
  if x, _ := l.shared.popTail(); x != nil {
   return x
  }
 }
 // Try the victim cache. We do this after attempting to steal
 // from all primary caches because we want objects in the
 // victim cache to age out if at all possible.
 size = atomic.LoadUintptr(&p.victimSize)
 if uintptr(pid) >= size {
  return nil
 }
 locals = p.victim
 l := indexLocal(locals, pid)
 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
  }
 }
 // Mark the victim cache as empty for future gets don't bother
 // with it.
 atomic.StoreUintptr(&p.victimSize, 0)
 return nil
}