Go语言核心手册-12.sync.Pool - 哈喽比特

413次阅读 | 发布于2年以前

12.1 基础知识

在 golang 中有一个池，它特别神奇，你只要和它有个约定，你要什么它就给什么，你用完了还可以还回去，但是下次拿的时候呢，确不一定是你上次存的那个，这个池就是 sync.Pool。

sync.Pool类型只有两个方法——Put和Get。Put 用于在当前的池中存放临时对象，它接受一个interface{}类型的参数；而 Get 则被用于从当前的池中获取临时对象，它会返回一个interface{}类型的值。更具体地说，这个类型的Get方法可能会从当前的池中删除掉任何一个值，然后把这个值作为结果返回。如果此时当前的池中没有任何值，那么这个方法就会使用当前池的New字段创建一个新值，并直接将其返回，先看个简单的示例：


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

通过New去定义你这个池子里面放的究竟是什么东西，在这个池子里面你只能放一种类型的东西，比如在上面的例子中我就在池子里面放了字符串。我们随时可以通过Get方法从池子里面获取我们之前在New里面定义类型的数据，当我们用完了之后可以通过Put方法放回去，或者放别的同类型的数据进去。

那么这个池子的目的是什么呢？其实一句话就可以说明白，就是为了复用已经使用过的对象，来达到优化内存使用和回收的目的。说白了，一开始这个池子会初始化一些对象供你使用，如果不够了呢，自己会通过new产生一些，当你放回去了之后这些对象会被别人进行复用，当对象特别大并且使用非常频繁的时候可以大大的减少对象的创建和回收的时间。

12.2 源码解析

12.2.1 Pool


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
}

我们可以看到其实结构并不复杂，但是如果自己看的话有点懵，注意几个细节就可以：

local这里面真正的是[P]poolLocal其中P就是GPM模型中的P，有多少个P数组就有多大，也就是每个P维护了一个本地的poolLocal。
poolLocal里面维护了一个private一个shared，看名字其实就很明显了，private是给自己用的，而shared的是一个队列，可以给别人用的。注释写的也很清楚，自己可以从队列的头部存然后从头部取，而别的P可以从尾部取。
victim这个从字面上面也可以知道，幸存者嘛，当进行gc的stw时候，会将local中的对象移到victim中去，也就是说幸存了一次gc。

12.2.2 Get

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
}

我去掉了其中一些竞态分析的代码，代码里面我也标明了每个step，Get的逻辑其实非常清晰：

如果 private 不是空的，那就直接拿来用；
如果 private 是空的，那就先去本地的shared队列里面从头 pop 一个；
如果本地的 shared 也没有了，那 getSlow 去拿，其实就是去别的P的 shared 里面偷，偷不到回去 victim 幸存者里面找；
如果最后都没有，那就只能调用 New 方法创建一个了。

再用一幅图描述一下：

12.2.3 Put


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()
    // ......
}

Put主要做2件事情：

如果 private 没有，就放在 private；
如果 private 有了，那么就放到 shared 队列的头部。

12.3 GMP调度

我们先回顾一下GMP的知识：

G表示Goroutine协程，M表示thread线程，P表示processor处理器；
M是G运行的实体，P的作用就是将G分配到M上；
一个P有个本地队列，专门用于存放G。

再回顾一下GMP核心的调度流程：

当程序运行时，P会从本地队列中随机取一个G，然后给到M运行；
当P的本地队列没有G时，会从全局对列中找一批G，然后放到自己的本地队列，然后再取出G；
当本地队列为空时，P会从其它的P的本地队列中抢一批G，然后放到自己的本地队列，然后再取出G；
当没有抢到时，M就自动挂起来，不运行了。

一句话总结一下，G和P都属于Goroutine调度器，就是通过G和P的各种协作，找一个P给到M，然后OS调度器就会去运行这个M，详细的知识可以阅读“GMP原理”章节。

我们再回到sync.Pool，它的Get代码是不是和GMP中P去抢G中很像呢？我们再深度解读一下：在程序调用临时对象池的Put方法或Get方法的时候，总会先试图从该临时对象池的本地池列表中，获取与之对应的本地池，依据的就是与当前的goroutine关联的那个P的ID。换句话说，一个临时对象池的Put方法或Get方法会获取到哪一个本地池，完全取决于调用它的代码所在的goroutine关联的那个 P，我们可以通过下面这幅图来描述：

pool结构体中的unsafe.Pointer，就是图中的本地池列表，一共有P个本地池，每个池子包含1个private和1个shared，其中shared是一个队列，里面装的就是对应的pool元素（注意图中的G不是pool元素，只是表示一个协程），然后对于13.2.2中的Get调度图，也可以通过下面这一幅图表述：

里面抢占pool数据的逻辑，和GMP中抢占G资源的逻辑，是不是很像呢？

12.4 总结

pool在掌握基础用法的同时，需要知道Get和Push方法的实现逻辑，其中最重要的一点，是需要将pool和GMP的调度原理结合起来，其中两者的P的原理其实是一样的，只是对于资源抢占这一块，GMP抢占的是G，pool抢占的是pool数据，对于这块，其实是自己个人的理解，如果理解的不对，还请大家帮忙指出。