type Pool struct {
  //noCopy标明该pool不应该被复制，结合go vet可实现代码检测
 noCopy noCopy 
  //local+localSize决定poolLocal
 local     unsafe.Pointer 
 localSize uintptr        
  //victim+victimSize接管poolLocal负责GC相关
 victim     unsafe.Pointer 
 victimSize uintptr        
  //构造新对象方法
 New func() interface{}
}

type poolLocal struct {
 poolLocalInternal
  //pad对齐 防止伪共享(false sharing) 后面单独介绍
 pad [128 - unsafe.Sizeof(poolLocalInternal{})%128]byte
}

type poolLocalInternal struct {
 private interface{}  //只能被owner P所使用.
 shared  poolChain //owner P 可以 pushHead/popHead操作; 其他P只允许popTail.
}

// poolChain的实现是一个双向队列,其中每个元素是前一个的双倍 
type poolChain struct {
  // head节点只能被producer访问，所以不需要同步机制 
  head *poolChainElt
  // tail节点被consumers访问，所以必须读写保证原子操作 
  tail *poolChainElt
}

type poolChainElt struct {
  poolDequeue
  next, prev *poolChainElt
}

//poolDequeue是一个无锁的固定大小单生产者，多消费者队列。 
type poolDequeue struct {
  headTail uint64 //存储head tail索引，通过mask和cas实现
  vals []eface //存储真正对象的数组
}

ptrs2 := d.pack(head, tail+1)
    if atomic.CompareAndSwapUint64(&d.headTail, ptrs, ptrs2) {
       // Success.
       slot = &d.vals[tail&uint32(len(d.vals)-1)]
       break
  }

head--
  ptrs2 := d.pack(head, tail)
  if atomic.CompareAndSwapUint64(&d.headTail, ptrs, ptrs2) {
     // We successfully took back slot.
     slot = &d.vals[head&uint32(len(d.vals)-1)]
     break
  }

func (p *Pool) Get() interface{} {
  // 获取当前P的对象池和Pid
 l, pid := p.pin()
 x := l.private
 l.private = nil
 if x == nil {
  //尝试从本地share队列头部pop
    x, _ = l.shared.popHead()
    if x == nil {
        //如果空,尝试从其他P的share队列尾部pop 窃取
       x = p.getSlow(pid)
     }
   }
  // 解绑groutine和P
 runtime_procUnpin()
  //如果还没有获取到对象，那么尝试构造新对象
 if x == nil && p.New != nil {
   x = p.New()
 }
 return x
}
func (p *Pool) getSlow(pid int) interface{} {
 size := runtime_LoadAcquintptr(&p.localSize)
 locals := p.local    
  // Try to steal one element from other procs.
  //尝试从其他P偷取一个对象
 for i := 0; i < int(size); i++ {
   l := indexLocal(locals, (pid+i+1)%int(size))
   if x, _ := l.shared.popTail(); x != nil {
      return x
  }
 }
 //尝试从victim cache中获取。因为我们尽可能想淘汰victim中的对象
  // 所以在尝试从所有的primary cache中获取失败后操作
 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
 }
  //从victim cache中窃取一个对象
 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
 //标记victim cache为空 即清理victim cache
 atomic.StoreUintptr(&p.victimSize, 0)
 return nil
}

func (p *Pool) Put(x interface{}) {
 if x == nil {
  return
 }
 //返回当前groutine所绑定的p,并且固定当前P和groutine的绑定
 l, _ := p.pin()
 //首先给private 
 if l.private == nil {
  l.private = x
  x = nil
 }
 //private不为空，就插入到当前head指向的双向链表节点的ringbuffer的head位置，并更新head索引。
 if x != nil {
  l.shared.pushHead(x)
 }
 //解绑P和当前groutine的固定关系
 runtime_procUnpin()
}

func poolCleanup() {
 // 函数将在gc开始前被调用.
 // 在gc stop word阶段,pool将不会产生外部函数调用分配对象的行为. 
 // 从oldPools中删除所有的victim cache.
 for _, p := range oldPools {
   p.victim = nil
   p.victimSize = 0
 }
 // 移动local cache到victim cache.
 //victim接管local
 for _, p := range allPools {
   p.victim = p.local
   p.victimSize = p.localSize
   p.local = nil
   p.localSize = 0
 }
 // 现在所有的local cache被移动到了victim cache中，local cache为空
 oldPools, allPools = allPools, nil
}