Go语言核心手册-12.sync.Pool

var strPool = sync.Pool{    New: func() interface{} {        return "test str"    },}func main() {    str := strPool.Get()    fmt.Println(str)    strPool.Put(str)}

type Pool struct {    noCopy noCopy    local     unsafe.Pointer  // 数组指针，指向[P]poolLocal    localSize uintptr         // 大小为P    victim     unsafe.Pointer // 用于存放“幸存者”    victimSize uintptr        // “幸存者”size    // 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{}}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) Get() interface{} {    // ......    l, pid := p.pin()    // Step1: 先直接获取自己的private,如果有，直接返回    x := l.private    l.private = nil    if x == nil {        // Step2: 如果private为空，就从自己的shared随便取一个        x, _ = l.shared.popHead()        if x == nil {            x = p.getSlow(pid)        }    }    runtime_procUnpin()    // ......    if x == nil && p.New != nil {        // Step5: 找了一圈都没有，自己New一个        x = p.New()    }    return x}
func (p *Pool) getSlow(pid int) interface{} {    size := atomic.LoadUintptr(&p.localSize)    locals := p.local    for i := 0; i < int(size); i++ {        l := indexLocal(locals, (pid+i+1)%int(size))        // Step3: 从其它的P中随便偷一个出来        if x, _ := l.shared.popTail(); x != nil {            return x        }    }    size = atomic.LoadUintptr(&p.victimSize)    if uintptr(pid) >= size {        return nil    }    // Step4: 从“幸存者”中找一个，找的逻辑和前面的一样，先private，再shared    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        }    }    atomic.StoreUintptr(&p.victimSize, 0)    return nil}

func (p *Pool) Put(x interface{}) {    if x == nil {        return    }    // ......    l, _ := p.pin()    if l.private == nil {        l.private = x        x = nil    }    if x != nil {        l.shared.pushHead(x)    }    runtime_procUnpin()    // ......}