Golang 語言臨時對象池 - sync-Pool

 1func main () {
 2 pool := &sync.Pool{
 3  New: func() interface{} {
 4   fmt.Println("New 一個新對象")
 5   return 0
 6  },
 7 }
 8
 9 // 取，臨時對象池中沒有數據，會調用 New，New 創建一個新對象直接返回，不會存儲在臨時對象池中
10 val := pool.Get().(int)
11 fmt.Println(val)
12
13 // 存
14 pool.Put(10)
15 // 手動調用 GC()，用於驗證 GC 之後，臨時對象池中的對象會被清空。
16 runtime.GC()
17
18 // 取
19 val2 := pool.Get().(int)
20 fmt.Println(val2)
21}
22
23

 1type Pool struct {
 2 noCopy noCopy
 3
 4 local     unsafe.Pointer // local fixed-size per-P pool, actual type is [P]poolLocal
 5 localSize uintptr        // size of the local array
 6
 7 victim     unsafe.Pointer // local from previous cycle
 8 victimSize uintptr        // size of victims array
 9
10 // New optionally specifies a function to generate
11 // a value when Get would otherwise return nil.
12 // It may not be changed concurrently with calls to Get.
13 New func() interface{}
14}
15
16

 1func poolCleanup() {
 2 // This function is called with the world stopped, at the beginning of a garbage collection.
 3 // It must not allocate and probably should not call any runtime functions.
 4
 5 // Because the world is stopped, no pool user can be in a
 6 // pinned section (in effect, this has all Ps pinned).
 7
 8 // Drop victim caches from all pools.
 9 for _, p := range oldPools {
10  p.victim = nil
11  p.victimSize = 0
12 }
13
14 // Move primary cache to victim cache.
15 for _, p := range allPools {
16  p.victim = p.local
17  p.victimSize = p.localSize
18  p.local = nil
19  p.localSize = 0
20 }
21
22 // The pools with non-empty primary caches now have non-empty
23 // victim caches and no pools have primary caches.
24 oldPools, allPools = allPools, nil
25}
26
27

 1// Local per-P Pool appendix.
 2type poolLocalInternal struct {
 3 private interface{} // Can be used only by the respective P.
 4 shared  poolChain   // Local P can pushHead/popHead; any P can popTail.
 5}
 6
 7type poolLocal struct {
 8 poolLocalInternal
 9
10 // Prevents false sharing on widespread platforms with
11 // 128 mod (cache line size) = 0 .
12 pad [128 - unsafe.Sizeof(poolLocalInternal{})%128]byte
13}
14
15

 1func (p *Pool) getSlow(pid int) interface{} {
 2 // See the comment in pin regarding ordering of the loads.
 3 size := runtime_LoadAcquintptr(&p.localSize) // load-acquire
 4 locals := p.local                            // load-consume
 5 // Try to steal one element from other procs.
 6 for i := 0; i < int(size); i++ {
 7  l := indexLocal(locals, (pid+i+1)%int(size))
 8  if x, _ := l.shared.popTail(); x != nil {
 9   return x
10  }
11 }
12
13 // Try the victim cache. We do this after attempting to steal
14 // from all primary caches because we want objects in the
15 // victim cache to age out if at all possible.
16 size = atomic.LoadUintptr(&p.victimSize)
17 if uintptr(pid) >= size {
18  return nil
19 }
20 locals = p.victim
21 l := indexLocal(locals, pid)
22 if x := l.private; x != nil {
23  l.private = nil
24  return x
25 }
26 for i := 0; i < int(size); i++ {
27  l := indexLocal(locals, (pid+i)%int(size))
28  if x, _ := l.shared.popTail(); x != nil {
29   return x
30  }
31 }
32
33 // Mark the victim cache as empty for future gets don't bother
34 // with it.
35 atomic.StoreUintptr(&p.victimSize, 0)
36
37 return nil
38}
39
40