我們通常用golang來構建高並發場景下的應用，但是由於golang內建的GC機制會影響應用的性能，為了減少GC，golang提供了對象重用的機制，也就是sync.Pool對象池。 sync.Pool是可伸縮的，並發安全的。其大小僅受限於內存的大小，可以被看作是一個存放可重用對象的值的容器。 設計的目的是存放已經分配的但是暫時不用的對象，在需要用到的時候直接從pool中取。
任何存放區其中的值可以在任何時候被刪除而不通知，在高負載下可以動態的擴容，在不活躍時對象池會收縮。
sync.Pool首先聲明了兩個結構體
// Local per-P Pool appendix. type poolLocalInternal struct { private interface{} // Can be used only by the respective P. shared []interface{} // Can be used by any P. Mutex // Protects shared. } type poolLocal struct { poolLocalInternal // Prevents false sharing on widespread platforms with // 128 mod (cache line size) = 0 . pad [128 - unsafe.Sizeof(poolLocalInternal{})%128]byte } 為了使得在多個goroutine中高效的使用goroutine，sync.Pool為每個P(對應CPU)都分配一個本地池，當執行Get或者Put操作的時候，會先將goroutine和某個P的子池關聯，再對該子池進行操作。 每個P的子池分為私有對象和共享列表對象，私有對象只能被特定的P訪問，共享列表對象可以被任何P訪問。因為同一時刻一個P只能執行一個goroutine，所以無需加鎖，但是對共享列表對象進行操作時，因為可能有多個goroutine同時操作，所以需要加鎖。
值得注意的是poolLocal結構體中有個pad成員，目的是為了防止false sharing。cache使用中常見的一個問題是false sharing。當不同的線程同時讀寫同一cache line上不同數據時就可能發生false sharing。false sharing會導致多核處理器上嚴重的系統性能下降。具體的可以參考偽共享(False Sharing)。
類型sync.Pool有兩個公開的方法，一個是Get，一個是Put, 我們先來看一下Put的源碼。
// Put adds x to the pool. func (p *Pool) Put(x interface{}) { if x == nil { return } if race.Enabled { if fastrand()%4 == 0 { // Randomly drop x on floor. return } race.ReleaseMerge(poolRaceAddr(x)) race.Disable() } l := p.pin() if l.private == nil { l.private = x x = nil } runtime_procUnpin() if x != nil { l.Lock() l.shared = append(l.shared, x) l.Unlock() } if race.Enabled { race.Enable() } } - 如果放入的值為空，直接return.
- 檢查當前goroutine的是否設置對象池私有值，如果沒有則將x賦值給其私有成員，並將x設置為nil。
- 如果當前goroutine私有值已經被設置，那么將該值追加到共享列表。
func (p *Pool) Get() interface{} { if race.Enabled { race.Disable() } l := p.pin() x := l.private l.private = nil runtime_procUnpin() if x == nil { l.Lock() last := len(l.shared) - 1 if last >= 0 { x = l.shared[last] l.shared = l.shared[:last] } l.Unlock() if x == nil { x = p.getSlow() } } if race.Enabled { race.Enable() if x != nil { race.Acquire(poolRaceAddr(x)) } } if x == nil && p.New != nil { x = p.New() } return x } - 嘗試從本地P對應的那個本地池中獲取一個對象值, 並從本地池沖刪除該值。
- 如果獲取失敗，那么從共享池中獲取, 並從共享隊列中刪除該值。
- 如果獲取失敗，那么從其他P的共享池中偷一個過來，並刪除共享池中的該值(p.getSlow())。
- 如果仍然失敗，那么直接通過New()分配一個返回值，注意這個分配的值不會被放入池中。New()返回用戶注冊的New函數的值，如果用戶未注冊New，那么返回nil。
最后我們來看一下init函數。
func init() { runtime_registerPoolCleanup(poolCleanup) } 可以看到在init的時候注冊了一個PoolCleanup函數，他會清除掉sync.Pool中的所有的緩存的對象，這個注冊函數會在每次GC的時候運行，所以sync.Pool中的值只在兩次GC中間的時段有效。
package main
import (
"sync"
"time"
"fmt"
)
var bytePool = sync.Pool{
New: func() interface{} {
b := make([]byte, 1024)
return &b
},
}
func main() {
//defer
//debug.SetGCPercent(debug.SetGCPercent(-1))
a := time.Now().Unix()
for i:=0;i<1000000000;i++{
obj := make([]byte, 1024)
_ = obj
}
b := time.Now().Unix()
for j:=0;j<1000000000;j++ {
obj := bytePool.Get().(*[]byte)
_ = obj
bytePool.Put(obj)
}
c := time.Now().Unix()
fmt.Println("without pool ", b - a, "s")
fmt.Println("with pool ", c - b, "s")
}
可見GC對性能影響不大，因為shared list太長也會耗時。
總結：
通過以上的解讀，我們可以看到，Get方法並不會對獲取到的對象值做任何的保證，因為放入本地池中的值有可能會在任何時候被刪除，但是不通知調用者。放入共享池中的值有可能被其他的goroutine偷走。 所以對象池比較適合用來存儲一些臨時切狀態無關的數據，但是不適合用來存儲數據庫連接的實例，因為存入對象池重的值有可能會在垃圾回收時被刪除掉，這違反了數據庫連接池建立的初衷。
根據上面的說法，Golang的對象池嚴格意義上來說是一個臨時的對象池，適用於儲存一些會在goroutine間分享的臨時對象。主要作用是減少GC，提高性能。在Golang中最常見的使用場景是fmt包中的輸出緩沖區。
在Golang中如果要實現連接池的效果，可以用container/list來實現，開源界也有一些現成的實現，比如go-commons-pool，具體的讀者可以去自行了解。