深入了解Go語(yǔ)言中sync.Pool的使用

更新時(shí)間：2023年04月09日 08:45:12 作者：starrySky

本文將介紹?Go?語(yǔ)言中的?sync.Pool并發(fā)原語(yǔ)，包括sync.Pool的基本使用方法、使用注意事項(xiàng)等的內(nèi)容，對(duì)我們了解Go語(yǔ)言有一定的幫助，需要的可以參考一下

1. 簡(jiǎn)介

本文將介紹 Go 語(yǔ)言中的 sync.Pool并發(fā)原語(yǔ)，包括sync.Pool的基本使用方法、使用注意事項(xiàng)等的內(nèi)容。能夠更好得使用sync.Pool來(lái)減少對(duì)象的重復(fù)創(chuàng)建，最大限度實(shí)現(xiàn)對(duì)象的重復(fù)使用，減少程序GC的壓力，以及提升程序的性能。

2. 問題引入

2.1 問題描述

這里我們實(shí)現(xiàn)一個(gè)簡(jiǎn)單的JSON序列化器，能夠?qū)崿F(xiàn)將一個(gè)map[string]int序列化為一個(gè)JSON字符串，實(shí)現(xiàn)如下:

func IntToStringMap(m map[string]int) (string, error) {
   // 定義一個(gè)bytes.Buffer,用于緩存數(shù)據(jù)
   var buf bytes.Buffer
   buf.Write([]byte("{"))
   for k, v := range m {
      buf.WriteString(fmt.Sprintf(`"%s":%d,`, k, v))
   }
   if len(m) > 0 {
      buf.Truncate(buf.Len() - 1) // 去掉最后一個(gè)逗號(hào)
   }
   buf.Write([]byte("}"))
   return buf.String(), nil
}

這里使用bytes.Buffer 來(lái)緩存數(shù)據(jù)，然后按照key:value的形式，將數(shù)據(jù)生成一個(gè)字符串，然后返回，實(shí)現(xiàn)是比較簡(jiǎn)單的。

每次調(diào)用IntToStringMap方法時(shí)，都會(huì)創(chuàng)建一個(gè)bytes.Buffer來(lái)緩存中間結(jié)果，而bytes.Buffer其實(shí)是可以被重用的，因?yàn)樾蛄谢?guī)則和其并沒有太大的關(guān)系，其只是作為一個(gè)緩存區(qū)來(lái)使用而已。

但是當(dāng)前的實(shí)現(xiàn)為每次調(diào)用IntToStringMap時(shí)，都會(huì)創(chuàng)建一個(gè)bytes.Buffer,如果在一個(gè)應(yīng)用中，請(qǐng)求并發(fā)量非常高時(shí)，頻繁創(chuàng)建和銷毀bytes.Buffer將會(huì)帶來(lái)較大的性能開銷，會(huì)導(dǎo)致對(duì)象的頻繁分配和垃圾回收，增加了內(nèi)存使用量和垃圾回收的壓力。

那有什么方法能夠讓bytes.Buffer能夠最大程度得被重復(fù)利用呢，避免重復(fù)的創(chuàng)建和回收呢？

2.2 解決方案

其實(shí)我們可以發(fā)現(xiàn)，為了讓bytes.Buffer能夠被重復(fù)利用，避免重復(fù)的創(chuàng)建和回收，我們此時(shí)只需要將bytes.Buffer緩存起來(lái)，在需要時(shí)，將其從緩存中取出；當(dāng)用完后，便又將其放回到緩存池當(dāng)中。這樣子，便不需要每次調(diào)用IntToStringMap方法時(shí)，就創(chuàng)建一個(gè)bytes.Buffer。

這里我們可以自己實(shí)現(xiàn)一個(gè)緩存池，當(dāng)需要對(duì)象時(shí)，可以從緩存池中獲取，當(dāng)不需要對(duì)象時(shí)，可以將對(duì)象放回緩存池中。IntToStringMap方法需要bytes.Buffer時(shí)，便從該緩存池中取，當(dāng)用完后，便重新放回緩存池中，等待下一次的獲取。下面是一個(gè)使用切片實(shí)現(xiàn)的一個(gè)bytes.Buffer緩存池。

type BytesBufferPool struct {
   mu   sync.Mutex
   pool []*bytes.Buffer
}

func (p *BytesBufferPool) Get() *bytes.Buffer {
   p.mu.Lock()
   defer p.mu.Unlock()
   n := len(p.pool)
   if n == 0 {
      // 當(dāng)緩存池中沒有對(duì)象時(shí),創(chuàng)建一個(gè)bytes.Buffer
      return &bytes.Buffer{}
   }
   // 有對(duì)象時(shí),取出切片最后一個(gè)元素返回
   v := p.pool[n-1]
   p.pool[n-1] = nil
   p.pool = p.pool[:n-1]
   return v
}

func (p *BytesBufferPool) Put(buffer *bytes.Buffer) {
   if buffer == nil {
      return
   }
   // 將bytes.Buffer放入到切片當(dāng)中
   p.mu.Lock()
   defer p.mu.Unlock()
   obj.Reset()
   p.pool = append(p.pool, buffer)
}

上面BytesBufferPool實(shí)現(xiàn)了一個(gè)bytes.Buffer的緩存池，其中Get方法用于從緩存池中取對(duì)象，如果沒有對(duì)象，就創(chuàng)建一個(gè)新的對(duì)象返回；Put方法用于將對(duì)象重新放入BytesBufferPool當(dāng)中，下面使用BytesBufferPool來(lái)優(yōu)化IntToStringMap。

// 首先定義一個(gè)BytesBufferPool
var buffers BytesBufferPool

func IntToStringMap(m map[string]int) (string, error) {
   // bytes.Buffer不再自己創(chuàng)建,而是從BytesBufferPool中取出
   buf := buffers.Get()
   // 函數(shù)結(jié)束后,將bytes.Buffer重新放回緩存池當(dāng)中
   defer buffers.Put(buf)
   buf.Write([]byte("{"))
   for k, v := range m {
      buf.WriteString(fmt.Sprintf(`"%s":%d,`, k, v))
   }
   if len(m) > 0 {
      buf.Truncate(buf.Len() - 1) // 去掉最后一個(gè)逗號(hào)
   }
   buf.Write([]byte("}"))
   return buf.String(), nil
}

到這里我們通過自己實(shí)現(xiàn)了一個(gè)緩存池，成功對(duì)InitToStringMap函數(shù)進(jìn)行了優(yōu)化，減少了bytes.Buffer對(duì)象頻繁的創(chuàng)建和回收，在一定程度上提高了對(duì)象的頻繁創(chuàng)建和回收。

但是，BytesBufferPool這個(gè)緩存池的實(shí)現(xiàn)，其實(shí)存在幾點(diǎn)問題，其一，只能用于緩存bytes.Buffer對(duì)象；其二，不能根據(jù)系統(tǒng)的實(shí)際情況，動(dòng)態(tài)調(diào)整對(duì)象池中緩存對(duì)象的數(shù)量。假如某段時(shí)間并發(fā)量較高，bytes.Buffer對(duì)象被大量創(chuàng)建，用完后，重新放回BytesBufferPool之后，將永遠(yuǎn)不會(huì)被回收，這有可能導(dǎo)致內(nèi)存浪費(fèi)，嚴(yán)重一點(diǎn)，也會(huì)導(dǎo)致內(nèi)存泄漏。

既然自定義緩存池存在這些問題，那我們不禁要問，Go語(yǔ)言標(biāo)準(zhǔn)庫(kù)中有沒有提供了更方便的方式，來(lái)幫助我們緩存對(duì)象呢？

別說(shuō)，還真有，Go標(biāo)準(zhǔn)庫(kù)提供了sync.Pool，可以用來(lái)緩存那些需要頻繁創(chuàng)建和銷毀的對(duì)象，而且它支持緩存任何類型的對(duì)象，同時(shí)sync.Pool是可以根據(jù)系統(tǒng)的實(shí)際情況來(lái)調(diào)整緩存池中對(duì)象的數(shù)量，如果一個(gè)對(duì)象長(zhǎng)時(shí)間未被使用，此時(shí)將會(huì)被回收掉。

相對(duì)于自己實(shí)現(xiàn)的緩沖池，sync.Pool的性能更高，充分利用多核cpu的能力，同時(shí)也能夠根據(jù)系統(tǒng)當(dāng)前使用對(duì)象的負(fù)載，來(lái)動(dòng)態(tài)調(diào)整緩沖池中對(duì)象的數(shù)量，而且使用起來(lái)也比較簡(jiǎn)單，可以說(shuō)是實(shí)現(xiàn)無(wú)狀態(tài)對(duì)象緩存池的不二之選。

下面我們來(lái)看看sync.Pool的基本使用方式，然后將其應(yīng)用到IntToStringMap方法的實(shí)現(xiàn)當(dāng)中。

3. 基本使用

3.1 使用方式

3.1.1 sync.Pool的基本定義

sync.Pool的定義如下: 提供了Get,Put兩個(gè)方法:

type Pool struct {
  noCopy noCopy

  local     unsafe.Pointer // local fixed-size per-P pool, actual type is [P]poolLocal
  localSize uintptr        // size of the local array

  victim     unsafe.Pointer // local from previous cycle
  victimSize uintptr        // size of victims array

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

Get方法: 從sync.Pool中取出緩存對(duì)象
Put方法: 將緩存對(duì)象放入到sync.Pool當(dāng)中
New函數(shù): 在創(chuàng)建sync.Pool時(shí)，需要傳入一個(gè)New函數(shù)，當(dāng)Get方法獲取不到對(duì)象時(shí)，此時(shí)將會(huì)調(diào)用New函數(shù)創(chuàng)建新的對(duì)象返回。

3.1.2 使用方式

當(dāng)使用sync.Pool時(shí)，通常需要以下幾個(gè)步驟:

首先使用sync.Pool定義一個(gè)對(duì)象緩沖池
在需要使用到對(duì)象時(shí)，從緩沖池中取出
當(dāng)使用完之后，重新將對(duì)象放回緩沖池中

下面是一個(gè)簡(jiǎn)單的代碼的示例，展示了使用sync.Pool大概的代碼結(jié)構(gòu):

type struct data{
    // 定義一些屬性
}
//1. 創(chuàng)建一個(gè)data對(duì)象的緩存池
var dataPool = sync.Pool{New: func() interface{} {
   return &data{}
}}

func Operation_A(){
    // 2. 需要用到data對(duì)象的地方，從緩存池中取出
    d := dataPool.Get().(*data)
    // 執(zhí)行后續(xù)操作
    // 3. 將對(duì)象重新放入緩存池中
    dataPool.Put(d)
}

3.2 使用例子

下面我們使用sync.Pool來(lái)對(duì)IntToStringMap進(jìn)行改造，實(shí)現(xiàn)對(duì)bytes.Buffer對(duì)象的重用，同時(shí)也能夠自動(dòng)根據(jù)系統(tǒng)當(dāng)前的狀況，自動(dòng)調(diào)整緩沖池中對(duì)象的數(shù)量。

// 1. 定義一個(gè)bytes.Buffer的對(duì)象緩沖池
var buffers sync.Pool = sync.Pool{
   New: func() interface{} {
      return &bytes.Buffer{}
   },
}
func IntToStringMap(m map[string]int) (string, error) {
   // 2. 在需要的時(shí)候,從緩沖池中取出一個(gè)bytes.Buffer對(duì)象
   buf := buffers.Get().(*bytes.Buffer)
   buf.Reset()
   // 3. 用完之后,將其重新放入緩沖池中
   defer buffers.Put(buf)
   buf.Write([]byte("{"))
   for k, v := range m {
      buf.WriteString(fmt.Sprintf(`"%s":%d,`, k, v))
   }
   if len(m) > 0 {
      buf.Truncate(buf.Len() - 1) // 去掉最后一個(gè)逗號(hào)
   }
   buf.Write([]byte("}"))
   return buf.String(), nil
}

上面我們使用sync.Pool實(shí)現(xiàn)了一個(gè)bytes.Buffer的緩沖池，在 IntToStringMap 函數(shù)中，我們從 buffers 中獲取一個(gè) bytes.Buffer 對(duì)象，并在函數(shù)結(jié)束時(shí)將其放回池中，避免了頻繁創(chuàng)建和銷毀 bytes.Buffer 對(duì)象的開銷。

同時(shí)，由于sync.Pool在IntToStringMap調(diào)用不頻繁的情況下，能夠自動(dòng)回收sync.Pool中的bytes.Buffer對(duì)象，無(wú)需用戶操心，也能減小內(nèi)存的壓力。而且其底層實(shí)現(xiàn)也有考慮到多核cpu并發(fā)執(zhí)行，每一個(gè)processor都會(huì)有其對(duì)應(yīng)的本地緩存，在一定程度也減少了多線程加鎖的開銷。

從上面可以看出，sync.Pool使用起來(lái)非常簡(jiǎn)單，但是其還是存在一些注意事項(xiàng)，如果使用不當(dāng)?shù)脑?，還是有可能會(huì)導(dǎo)致內(nèi)存泄漏等問題的，下面就來(lái)介紹sync.Pool使用時(shí)的注意事項(xiàng)。

4.使用注意事項(xiàng)

4.1 需要注意放入對(duì)象的大小

如果不注意放入sync.Pool緩沖池中對(duì)象的大小，可能出現(xiàn)sync.Pool中只存在幾個(gè)對(duì)象，卻占據(jù)了大量的內(nèi)存，導(dǎo)致內(nèi)存泄漏。

這里對(duì)于有固定大小的對(duì)象，并不需要太過注意放入sync.Pool中對(duì)象的大小，這種場(chǎng)景出現(xiàn)內(nèi)存泄漏的可能性小之又小。但是，如果放入sync.Pool中的對(duì)象存在自動(dòng)擴(kuò)容的機(jī)制，如果不注意放入sync.Pool中對(duì)象的大小，此時(shí)將很有可能導(dǎo)致內(nèi)存泄漏。下面來(lái)看一個(gè)例子:

func Sprintf(format string, a ...any) string {
   p := newPrinter()
   p.doPrintf(format, a)
   s := string(p.buf)
   p.free()
   return s
}

Sprintf方法根據(jù)傳入的format和對(duì)應(yīng)的參數(shù)，完成組裝，返回對(duì)應(yīng)的字符串結(jié)果。按照普通的思路，此時(shí)只需要申請(qǐng)一個(gè)byte數(shù)組，然后根據(jù)一定規(guī)則，將format和參數(shù)的內(nèi)容放入byte數(shù)組中，最終將byte數(shù)組轉(zhuǎn)換為字符串返回即可。

按照上面這個(gè)思路我們發(fā)現(xiàn)，其實(shí)每次使用到的byte數(shù)組是可復(fù)用的，并不需要重復(fù)構(gòu)建。

實(shí)際上Sprintf方法的實(shí)現(xiàn)也是如此，byte數(shù)組其實(shí)并非每次創(chuàng)建一個(gè)新的，而是會(huì)對(duì)其進(jìn)行復(fù)用。其實(shí)現(xiàn)了一個(gè)pp結(jié)構(gòu)體，format和參數(shù)按照一定規(guī)則組裝成字符串的職責(zé)，交付給pp結(jié)構(gòu)體，同時(shí)byte數(shù)組作為pp結(jié)構(gòu)體的成員變量。

然后將pp的實(shí)例放入sync.Pool當(dāng)中，實(shí)現(xiàn)pp重復(fù)使用目的，從而簡(jiǎn)介避免了重復(fù)創(chuàng)建byte數(shù)組導(dǎo)致頻繁的GC，同時(shí)也提升了性能。下面是newPrinter方法的邏輯，獲取pp結(jié)構(gòu)體，都是從sync.Pool中獲取:

var ppFree = sync.Pool{
   New: func() any { return new(pp) },
}

// newPrinter allocates a new pp struct or grabs a cached one.
func newPrinter() *pp {
    // 從ppFree中獲取pp
   p := ppFree.Get().(*pp)
   // 執(zhí)行一些初始化邏輯
   p.panicking = false
   p.erroring = false
   p.wrapErrs = false
   p.fmt.init(&p.buf)
   return p
}

下面回到上面的byte數(shù)組，此時(shí)其作為pp結(jié)構(gòu)體的一個(gè)成員變量，用于字符串格式化的中間結(jié)果，定義如下:

// Use simple []byte instead of bytes.Buffer to avoid large dependency.
type buffer []byte

type pp struct {
   buf buffer
   // 省略掉其他不相關(guān)的字段
}

這里看起來(lái)似乎沒啥問題，但是其實(shí)是有可能存在內(nèi)存浪費(fèi)甚至內(nèi)存泄漏的問題。假如此時(shí)存在一個(gè)非常長(zhǎng)的字符串需要格式化，此時(shí)調(diào)用Sprintf來(lái)實(shí)現(xiàn)格式化，此時(shí)pp結(jié)構(gòu)體中的buffer也同樣需要不斷擴(kuò)容，直到能夠存儲(chǔ)整個(gè)字符串的長(zhǎng)度為止，此時(shí)pp結(jié)構(gòu)體中的buffer將會(huì)占據(jù)比較大的內(nèi)存。

當(dāng)Sprintf方法完成之后，重新將pp結(jié)構(gòu)體放入sync.Pool當(dāng)中，此時(shí)pp結(jié)構(gòu)體中的buffer占據(jù)的內(nèi)存將不會(huì)被釋放。

但是，如果下次調(diào)用Sprintf方法來(lái)格式化的字符串，長(zhǎng)度并沒有那么長(zhǎng)，但是此時(shí)從sync.Pool中取出的pp結(jié)構(gòu)體中的byte數(shù)組長(zhǎng)度卻是上次擴(kuò)容之后的byte數(shù)組，此時(shí)將會(huì)導(dǎo)致內(nèi)存浪費(fèi)，嚴(yán)重點(diǎn)甚至可能導(dǎo)致內(nèi)存泄漏。

因此，因?yàn)?code>pp對(duì)象中buffer字段占據(jù)的內(nèi)存是會(huì)自動(dòng)擴(kuò)容的，對(duì)象的大小是不固定的，因此將pp對(duì)象重新放入sync.Pool中時(shí)，需要注意放入對(duì)象的大小，如果太大，可能會(huì)導(dǎo)致內(nèi)存泄漏或者內(nèi)存浪費(fèi)的情況，此時(shí)可以直接拋棄，不重新放入sync.Pool當(dāng)中。事實(shí)上，pp結(jié)構(gòu)體重新放入sync.Pool也是基于該邏輯，其會(huì)先判斷pp結(jié)構(gòu)體中buffer字段占據(jù)的內(nèi)存大小，如果太大，此時(shí)將不會(huì)重新放入sync.Pool當(dāng)中，而是直接丟棄，具體如下:

func (p *pp) free() {
   // 如果byte數(shù)組的大小超過一定限度，此時(shí)將會(huì)直接返回
   if cap(p.buf) > 64<<10 {
      return
   }

   p.buf = p.buf[:0]
   p.arg = nil
   p.value = reflect.Value{}
   p.wrappedErr = nil
   
   // 否則,則重新放回sync.Pool當(dāng)中
   ppFree.Put(p)
}

基于以上總結(jié)，如果sync.Pool中存儲(chǔ)的對(duì)象占據(jù)的內(nèi)存大小是不固定的話，此時(shí)需要注意放入對(duì)象的大小，防止內(nèi)存泄漏或者內(nèi)存浪費(fèi)。

4.2 不要往sync.Pool中放入數(shù)據(jù)庫(kù)連接/TCP連接

TCP連接和數(shù)據(jù)庫(kù)連接等資源的獲取和釋放通常需要遵循一定的規(guī)范，比如需要在連接完成后顯式地關(guān)閉連接等，這些規(guī)范是基于網(wǎng)絡(luò)協(xié)議、數(shù)據(jù)庫(kù)協(xié)議等規(guī)范而制定的，如果這些規(guī)范沒有被正確遵守，就可能導(dǎo)致連接泄漏、連接池資源耗盡等問題。

當(dāng)使用 sync.Pool 存儲(chǔ)連接對(duì)象時(shí)，如果這些連接對(duì)象并沒有顯式的關(guān)閉，那么它們就會(huì)在內(nèi)存中一直存在，直到進(jìn)程結(jié)束。如果連接對(duì)象數(shù)量過多，那么這些未關(guān)閉的連接對(duì)象就會(huì)占用過多的內(nèi)存資源，導(dǎo)致內(nèi)存泄漏等問題。

舉個(gè)例子，假設(shè)有一個(gè)對(duì)象Conn表示數(shù)據(jù)庫(kù)連接，它的Close方法用于關(guān)閉連接。如果將Conn對(duì)象放入sync.Pool中，并在從池中取出并使用后沒有手動(dòng)調(diào)用Close方法歸還對(duì)象，那么這些連接就會(huì)一直保持打開狀態(tài)，直到程序退出或達(dá)到連接數(shù)限制等情況。這可能會(huì)導(dǎo)致資源耗盡或其他一些問題。

以下是一個(gè)簡(jiǎn)單的示例代碼，使用 sync.Pool 存儲(chǔ)TCP連接對(duì)象，演示了連接對(duì)象泄漏的情況：

import (
   "fmt"
   "net"
   "sync"
   "time"
)

var pool = &sync.Pool{
   New: func() interface{} {
      conn, err := net.Dial("tcp", "localhost:8000")
      if err != nil {
         panic(err)
      }
      return conn
   },
}

func main() {

   // 模擬使用連接
   for i := 0; i < 100; i++ {
      conn := pool.Get().(net.Conn)
      time.Sleep(100 * time.Millisecond)
      fmt.Fprintf(conn, "GET / HTTP/1.0\r\n\r\n")
      // 不關(guān)閉連接
      // 不在使用連接時(shí)，釋放連接對(duì)象到池中即可
      pool.Put(conn)
   }

}

在上面的代碼中，我們使用 net.Dial 創(chuàng)建了一個(gè) TCP 連接，并將其存儲(chǔ)到 sync.Pool 中。在模擬使用連接時(shí)，我們從池中獲取連接對(duì)象，向服務(wù)器發(fā)送一個(gè)簡(jiǎn)單的 HTTP 請(qǐng)求，然后將連接對(duì)象釋放到池中。但是，我們沒有顯式地關(guān)閉連接對(duì)象。如果連接對(duì)象的數(shù)量很大，那么這些未關(guān)閉的連接對(duì)象就會(huì)占用大量的內(nèi)存資源，導(dǎo)致內(nèi)存泄漏等問題。

因此，對(duì)于數(shù)據(jù)庫(kù)連接或者TCP連接這種資源的釋放需要遵循一定的規(guī)范，此時(shí)不應(yīng)該使用sync.Pool來(lái)復(fù)用，可以自己實(shí)現(xiàn)數(shù)據(jù)庫(kù)連接池等方式來(lái)實(shí)現(xiàn)連接的復(fù)用。

5. 總結(jié)

本文介紹了 Go 語(yǔ)言中的 sync.Pool原語(yǔ)，它是實(shí)現(xiàn)對(duì)象重復(fù)利用，降低程序GC頻次，提高程序性能的一個(gè)非常好的工具。

我們首先通過一個(gè)簡(jiǎn)單的JSON序列化器的實(shí)現(xiàn)，引入了需要對(duì)象重復(fù)使用的場(chǎng)景，進(jìn)而自己實(shí)現(xiàn)了一個(gè)緩沖池，由該緩沖池存在的問題，進(jìn)而引出sync.Pool。接著，我們介紹了sync.Pool的基本使用以及將其應(yīng)用到JSON序列化器的實(shí)現(xiàn)當(dāng)中。

在接下來(lái)，介紹了sync.Pool常見的注意事項(xiàng)，如需要注意放入sync.Pool對(duì)象的大小，對(duì)其進(jìn)行了分析,從而講述了sync.Pool可能存在的一些注意事項(xiàng)，幫忙大家更好得對(duì)其進(jìn)行使用。

以上就是深入了解Go語(yǔ)言中sync.Pool的使用的詳細(xì)內(nèi)容，更多關(guān)于Go語(yǔ)言 sync.Pool的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: