深刻Golang之sync.Pool詳解

咱們一般用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()
	}
}

1. 若是放入的值爲空，直接return.
2. 檢查當前goroutine的是否設置對象池私有值，若是沒有則將x賦值給其私有成員，並將x設置爲nil。
3. 若是當前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
}

1. 嘗試從本地P對應的那個本地池中獲取一個對象值, 並從本地池衝刪除該值。
2. 若是獲取失敗，那麼從共享池中獲取, 並從共享隊列中刪除該值。
3. 若是獲取失敗，那麼從其餘P的共享池中偷一個過來，並刪除共享池中的該值(p.getSlow())。
4. 若是仍然失敗，那麼直接經過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，具體的讀者能夠去自行了解。

 

參考資料：

• go語言的官方包sync.Pool的實現原理和適用場景
• sync.Pool源碼