特性

  1. sync.Pool 类型值看作是存放可被重复使用的值的容器。此类容器是自动伸缩的、高效的，同时也是并发安全的，其大小仅受限于内存的大小。为了描述方便，我们也会把sync.Pool类型的值称为临时对象池，而把存于其中的值称为对象值。
  2. 设计的目的是存放已经分配的但是暂时不用的对象，在需要用到的时候直接从pool中取。
  3. 在高负载下可以动态的扩容，在不活跃时对象池会收缩。
  4. 当前遇到程序gc用时比较多的问题, 堆对象有点多, 可以有效缓解这一问题, 值得尝试。
  5. 存放在其中的值可以在任何时候被GC删除而不通知。垃圾回收的执行一般会使临时对象池中的对象值被全部移除。也就是说，即使我们永远不会显式的从临时对象池取走某一个对象值，该对象值也不会永远待在临时对象池中。它的生命周期取决于垃圾回收任务下一次的执行时间。

源码

定义

  1. // Local per-P Pool appendix.
  2. type poolLocalInternal struct {
  3.     private interface{}   // Can be used only by the respective P.
  4.     shared  []interface{} // Can be used by any P.
  5.     Mutex                 // Protects shared.
  6. }
  8. type poolLocal struct {
  9.     poolLocalInternal
  11.     // Prevents false sharing on widespread platforms with
  12.     // 128 mod (cache line size) = 0 .
  13.     pad [128 - unsafe.Sizeof(poolLocalInternal{})%128]byte
  14. }
  1. 为了使得在多个goroutine中高效的使用该对象，sync.Pool为每个P(对应CPU)都分配一个本地池，当执行Get或者Put操作的时候，会先将goroutine和某个P的子池关联，再对该子池进行操作。 每个P的子池分为私有对象和共享列表对象，私有对象只能被特定的P访问，共享列表对象可以被任何P访问。因为同一时刻一个P只能执行一个goroutine，所以无需加锁，但是对共享列表对象进行操作时，因为可能有多个goroutine同时操作，所以需要加锁。
  2. 值得注意的是poolLocal结构体中有个pad成员，目的是为了防止false sharing。cache使用中常见的一个问题是false sharing。当不同的线程同时读写同一cache line上不同数据时就可能发生false sharing。false sharing会导致多核处理器上严重的系统性能下降。具体的可以参考伪共享(False Sharing)。

方法

Put

把一个interface{}类型的值放置于池中。该方法会把它的参数值存放到与当前P对应的那个本地池中。每个P的本地池中的绝大多数对象值都是被同一个临时对象池中的所有本地池所共享的。也就是说，它们随时可能会被偷走。

  1. // Put adds x to the pool.
  2. func (p *Pool) Put(x interface{}) {
  3.     if x == nil {
  4.         return
  5.     }
  6.     if race.Enabled {
  7.         if fastrand()%4 == 0 {
  8.             // Randomly drop x on floor.
  9.             return
  10.         }
  11.         race.ReleaseMerge(poolRaceAddr(x))
  12.         race.Disable()
  13.     }
  14.     l := p.pin()
  15.     if l.private == nil {
  16.         l.private = x
  17.         x = nil
  18.     }
  19.     runtime_procUnpin()
  20.     if x != nil {
  21.         l.Lock()
  22.         l.shared = append(l.shared, x)
  23.         l.Unlock()
  24.     }
  25.     if race.Enabled {
  26.         race.Enable()
  27.     }
  28. }
  1. 如果放入的值为空，直接return。
  2. 检查当前goroutine的是否设置对象池私有值，如果没有则将x赋值给其私有成员，并将x设置为nil。
  3. 如果当前goroutine私有值已经被设置，那么将该值追加到共享列表。

Get

从池中获取一个interface{}类型的值。通过Get方法获取到的值是任意的，并且返回后会把该对象从池中删除。如果一个临时对象池的Put方法未被调用过，且它的New字段也未曾被赋予一个非nil的函数值，那么它的Get方法返回的结果值就一定会是nil。

  1. func (p *Pool) Get() interface{} {
  2.     if race.Enabled {
  3.         race.Disable()
  4.     }
  5.     l := p.pin()
  6.     x := l.private
  7.     l.private = nil
  8.     runtime_procUnpin()
  9.     if x == nil {
  10.         l.Lock()
  11.         last := len(l.shared) - 1
  12.         if last >= 0 {
  13.             x = l.shared[last]
  14.             l.shared = l.shared[:last]
  15.         }
  16.         l.Unlock()
  17.         if x == nil {
  18.             x = p.getSlow()
  19.         }
  20.     }
  21.     if race.Enabled {
  22.         race.Enable()
  23.         if x != nil {
  24.             race.Acquire(poolRaceAddr(x))
  25.         }
  26.     }
  27.     if x == nil && p.New != nil {
  28.         x = p.New()
  29.     }
  30.     return x
  31. }
  1. 尝试从本地P对应的那个本地池中获取一个对象值, 并从本地池冲删除该值。
  2. 如果获取失败，那么从共享池中获取, 并从共享队列中删除该值。
  3. 如果获取失败，那么从其他P的共享池中偷一个过来，并删除共享池中的该值(p.getSlow())。
  4. 如果仍然失败，那么直接通过New()分配一个返回值，注意这个分配的值不会被放入池中。New()返回用户注册的New函数的值，如果用户未注册New，那么返回nil。

init

  1. func init() {
  2.     runtime_registerPoolCleanup(poolCleanup)
  3. }

可以看到在init的时候注册了一个PoolCleanup函数，他会清除掉sync.Pool中的所有的缓存的对象，这个注册函数会在每次GC的时候运行，所以sync.Pool中的值只在两次GC中间的时段有效。

栗子

  1. func main() {
  2.     // 禁用GC，并保证在main函数执行结束前恢复GC
  3.     defer debug.SetGCPercent(debug.SetGCPercent(-1))
  4.     var count int32
  5.     newFunc := func() interface{} {
  6.         return atomic.AddInt32(&count, 1)
  7.     }
  8.     pool := sync.Pool{New: newFunc}
  10.     // New 字段值的作用
  11.     v1 := pool.Get()
  12.     fmt.Printf("v1: %v\n", v1)
  14.     // 临时对象池的存取
  15.     pool.Put(newFunc())
  16.     pool.Put(newFunc())
  17.     pool.Put(newFunc())
  18.     v2 := pool.Get()
  19.     fmt.Printf("v2: %v\n", v2)
  21.     // 垃圾回收对临时对象池的影响
  22.     debug.SetGCPercent(100)
  23.     runtime.GC()
  24.     v3 := pool.Get()
  25.     fmt.Printf("v3: %v\n", v3)
  26.     pool.New = nil
  27.     v4 := pool.Get()
  28.     fmt.Printf("v4: %v\n", v4)
  29. }

运行结果

  1. v1: 1
  2. v2: 2
  3. v3: 5
  4. v4: <nil>

总结

  1. Get方法并不会对获取到的对象值做任何的保证，因为放入本地池中的值有可能会在任何时候被删除，但是不通知调用者。放入共享池中的值有可能被其他的goroutine偷走。 所以对象池比较适合用来存储一些临时切状态无关的数据，但是不适合用来存储数据库连接的实例，因为存入对象池重的值有可能会在垃圾回收时被删除掉，这违反了数据库连接池建立的初衷。
  2. 根据上面的说法，Golang的对象池严格意义上来说是一个临时的对象池，适用于储存一些会在goroutine间分享的临时对象。主要作用是减少GC，提高性能。在Golang中最常见的使用场景是fmt包中的输出缓冲区。

感谢

http://ifeve.com/go-concurrency-object-pool/
https://www.cnblogs.com/sunsky303/p/9706210.html