剖析Go1.3新特性:sync.Pool

這是一個建立於 的文章，其中的資訊可能已經有所發展或是發生改變。

Go 1.3 的sync包中加入一個新特性：Pool。官方文檔可以看這裡http://golang.org/pkg/sync/#Pool

這個類設計的目的是用來儲存和複用臨時對象，以減少記憶體配置，降低CG壓力。

type Pool    func (p *Pool) Get() interface{}    func (p *Pool) Put(x interface{})    New func() interface{}

Get返回Pool中的任意一個對象。如果Pool為空白，則調用New返回一個新建立的對象。如果沒有設定New，則返回nil。

還有一個重要的特性是，放進Pool中的對象，會在說不準什麼時候被回收掉。所以如果事先Put進去100個對象，下次Get的時候發現Pool是空也是有可能的。不過這個特性的一個好處就在於不用擔心Pool會一直增長，因為Go已經幫你在Pool中做了回收機制。之前我用Channel實現過一個類似介面的Pool，看到這個官方版本之後果斷就拋棄了。

下面說說Pool的實現：

1.定時清理

文檔上說，儲存在Pool中的對象會在沒有任何通知的情況下被自動移除掉。實際上，這個清理過程是在每次記憶體回收之前做的。記憶體回收是固定兩分鐘觸發一次。而且每次清理會將Pool中的所有對象都清理掉！（我在看源碼之前還以為會按照使用頻率清理一部分…）所以如果Pool中的對象數量很多也會拖慢記憶體回收的時間。

var (allPoolsMu MutexallPools   []*Pool)func poolCleanup() {// This function is called with the world stopped, at the beginning of a garbage collection.// It must not allocate and probably should not call any runtime functions.// Defensively zero out everything, 2 reasons:// 1. To prevent false retention of whole Pools.// 2. If GC happens while a goroutine works with l.shared in Put/Get,//    it will retain whole Pool. So next cycle memory consumption would be doubled.for i, p := range allPools {allPools[i] = nilfor i := 0; i < int(p.localSize); i++ {l := indexLocal(p.local, i)l.private = nilfor j := range l.shared {l.shared[j] = nil}l.a = nil}}allPools = []*Pool{}}func init() {runtime_registerPoolCleanup(poolCleanup)}

有一個全域變數allPools儲存了所有被建立出來的Pool對象，並註冊了一個poolCleanup函數回調給runtime，這個函數將會在每次記憶體回收之前調用。

2.如何管理資料

先看看兩個資料結構

type Pool struct {local     unsafe.Pointer // local fixed-size per-P pool, actual type is [P]poolLocallocalSize uintptr        // size of the local array// 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{}}// Local per-P Pool appendix.type poolLocal struct {private interface{}   // Can be used only by the respective P.shared  []interface{} // Can be used by any P.Mutex                 // Protects shared.pad     [128]byte     // Prevents false sharing.}

Pool是提供給外部使用的對象。其中的local成員的真實類型是一個poolLocal數組，localSize是數組長度。poolLocal是真正儲存資料的地方。priveate儲存了一個臨時對象，shared是儲存臨時對象的數組。

為什麼Pool中需要這麼多poolLocal對象呢？實際上，Pool是給每個線程分配了一個poolLocal對象。也就是說local數組的長度，就是背景工作執行緒的數量(size := runtime.GOMAXPROCS(0))。當多線程在並發讀寫的時候，通常情況下都是在自己線程的poolLocal中存取資料。當自己線程的poolLocal中沒有資料時，才會嘗試加鎖去其他線程的poolLocal中“偷”資料。

func (p *Pool) Get() interface{} {if raceenabled {if p.New != nil {return p.New()}return nil}l := p.pin()  // 擷取當前線程的poolLocal對象，也就是p.local[pid]。x := l.privatel.private = nilruntime_procUnpin()if x != nil {return x}l.Lock()last := len(l.shared) - 1if last >= 0 {x = l.shared[last]l.shared = l.shared[:last]}l.Unlock()if x != nil {return x}return p.getSlow()}

Pool.Get的時候，首先會在local數組中擷取當前線程對應的poolLocal對象。如果private中有資料，則取出來直接返回。如果沒有則先鎖住shared，有資料則直接返回。

為什麼這裡要鎖住。答案在getSlow中。因為當shared中沒有資料的時候，會嘗試去其他的poolLocal的shared中偷資料。

func (p *Pool) getSlow() (x interface{}) {// See the comment in pin regarding ordering of the loads.size := atomic.LoadUintptr(&p.localSize) // load-acquirelocal := p.local                         // load-consume// Try to steal one element from other procs.pid := runtime_procPin()runtime_procUnpin()for i := 0; i < int(size); i++ {l := indexLocal(local, (pid+i+1)%int(size))l.Lock()last := len(l.shared) - 1if last >= 0 {x = l.shared[last]l.shared = l.shared[:last]l.Unlock()break}l.Unlock()}if x == nil && p.New != nil {x = p.New()}return x}

Go語言的goroutine雖然可以建立很多，但是真正能物理上並發啟動並執行goroutine數量是有限的，是由runtime.GOMAXPROCS(0)設定的。所以這個Pool高效的設計的地方就在於將資料分散在了各個真正並發的線程中，每個線程優先從自己的poolLocal中擷取資料，很大程度上降低了鎖競爭。