浅谈Golang对象池sync.pool

package main
import (
  "fmt"
  "reflect"
  "sync"
)
func syncPool() {
  var sp = sync.Pool{
    // Tip: 声明对象池的New函数，这里以一个简单的int为例
    New: func() interface{} {
      return 100
    },
  }
  // Tip: 从对象池里获取一个对象
  data := sp.Get().(int)
  fmt.Println(data)
  // Tip: 往对象池里放回一个对象
  sp.Put(data)
  fmt.Println(reflect.ValueOf(sp))
}

//Get local private -> local shared -> remote shared ->victim -> New
func (p *Pool) Get() interface{} {
  x := l.private//先从local private拿
  l.private = nil
  if x == nil {
    x, _ = l.shared.popHead()//private没有的话从local shared拿
    if x == nil {
      x = p.getSlow(pid)//local没有就从remote shared拿，再没有就从victim拿，详情看下面函数代码
    }
  }
  if x == nil && p.New != nil {
    x = p.New()//都没有只能New一个了
  }
  return x
}
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
  //这里，从其他的process shared上面取
  // 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//没有的话从victim上拿
  return nil
}

// Put adds x to the pool.
//local private-> local shared
func (p *Pool) Put(x interface{}) {
  if l.private == nil {
    l.private = x
    x = nil
  }
  if x != nil {
    l.shared.pushHead(x)
  }
}

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
}