go并發利器sync.Once如何使用

這篇文章主要介紹了go并發利器sync.Once如何使用的相關知識，內容詳細易懂，操作簡單快捷，具有一定借鑒價值，相信大家閱讀完這篇go并發利器sync.Once如何使用文章都會有所收獲，下面我們一起來看看吧。

1. 簡介

本文主要介紹 Go 語言中的 Once 并發原語，包括 Once 的基本使用方法、原理和注意事項，從而對 Once 的使用有基本的了解。

2. 基本使用

2.1 基本定義

sync.Once是Go語言中的一個并發原語，用于保證某個函數只被執行一次。Once類型有一個Do方法，該方法接收一個函數作為參數，并在第一次調用時執行該函數。如果Do方法被多次調用，只有第一次調用會執行傳入的函數。

2.2 使用方式

使用sync.Once非常簡單，只需要創建一個Once類型的變量，然后在需要保證函數只被執行一次的地方調用其Do方法即可。下面是一個簡單的例子：

var once sync.Once
func initOperation() {
    // 這里執行一些初始化操作，只會被執行一次
}
func main() {
    // 在程序啟動時執行initOperation函數，保證初始化只被執行一次
    once.Do(initOperation)   
    // 后續代碼
}

2.3 使用例子

下面是一個簡單使用sync.Once的例子，其中我們使用sync.Once來保證全局變量config只會被初始化一次：

package main
import (
    "fmt"
    "sync"
)
var (
    config map[string]string
    once   sync.Once
)
func loadConfig() {
    // 模擬從配置文件中加載配置信息
    fmt.Println("load config...")
    config = make(map[string]string)
    config["host"] = "127.0.0.1"
    config["port"] = "8080"
}
func GetConfig() map[string]string {
    once.Do(loadConfig)
    return config
}
func main() {
    // 第一次調用GetConfig會執行loadConfig函數，初始化config變量
    fmt.Println(GetConfig())
    // 第二次調用GetConfig不會執行loadConfig函數，直接返回已初始化的config變量
    fmt.Println(GetConfig())
}

在這個例子中，我們定義了一個全局變量config和一個sync.Once類型的變量once。在GetConfig函數中，我們通過調用once.Do方法來保證loadConfig函數只會被執行一次，從而保證config變量只會被初始化一次。 運行上面的程序，輸出如下:

load config...
map[host:127.0.0.1 port:8080]
map[host:127.0.0.1 port:8080]

可以看到，GetConfig函數在第一次調用時執行了loadConfig函數，初始化了config變量。在第二次調用時，loadConfig函數不會被執行，直接返回已經初始化的config變量。

3. 原理

下面是sync.Once的具體實現如下：

type Once struct {
   done uint32
   m    Mutex
}
func (o *Once) Do(f func()) {    
    // 判斷done標記位是否為0
   if atomic.LoadUint32(&o.done) == 0 {
      // Outlined slow-path to allow inlining of the fast-path.
      o.doSlow(f)
   }
}
func (o *Once) doSlow(f func()) {
   // 加鎖
   o.m.Lock()
   defer o.m.Unlock()
   // 執行雙重檢查,再次判斷函數是否已經執行
   if o.done == 0 {
      defer atomic.StoreUint32(&o.done, 1)
      f()
   }
}

sync.Once的實現原理比較簡單，主要依賴于一個done標志位和一個互斥鎖。當Do方法被第一次調用時，會先原子地讀取done標志位，如果該標志位為0，說明函數還沒有被執行過，此時會加鎖并執行傳入的函數，并將done標志位置為1，然后釋放鎖。如果標志位為1，說明函數已經被執行過了，直接返回。

4. 使用注意事項

4.1 不能將sync.Once作為函數局部變量

下面是一個簡單的例子，說明將 sync.Once 作為局部變量會導致的問題：

var config map[string]string
func initConfig() {
    fmt.Println("initConfig called")
    config["1"] = "hello world"
}
func getConfig() map[string]string{
    var once sync.Once
    once.Do(initCount)
    fmt.Println("getConfig called")
}
func main() {
    for i := 0; i < 10; i++ {
        go getConfig()
    }
    time.Sleep(time.Second)
}

這里初始化函數會被多次調用，這與initConfig 方法只會執行一次的預期不符。這是因為將 sync.Once 作為局部變量時，每次調用函數都會創建新的 sync.Once 實例，每個 sync.Once 實例都有自己的 done 標志，多個實例之間無法共享狀態。導致初始化函數會被多次調用。

如果將 sync.Once 作為全局變量或包級別變量，就可以避免這個問題。所以基于此，不能定義sync.Once 作為函數局部變量來使用。

4.2 不能在once.Do中再次調用once.Do

下面舉一個在once.Do方法中再次調用once.Do 方法的例子:

package main
import (
"fmt"
"sync"
)
func main() {
   var once sync.Once
   var onceBody func()
   onceBody = func() {
      fmt.Println("Only once")
      once.Do(onceBody) // 再次調用once.Do方法
   }
   // 執行once.Do方法
   once.Do(onceBody)
   fmt.Println("done")
}

在上述代碼中，當once.Do(onceBody)第一次執行時，會輸出"Only once"，然后在執行once.Do(onceBody)時會發生死鎖，程序無法繼續執行下去。

這是因為once.Do()方法在執行過程中會獲取互斥鎖，在方法內再次調用once.Do()方法，那么就會在獲取互斥鎖時出現死鎖。

因此，我們不能在once.Do方法中再次調用once.Do方法。

4.3 需要對傳入的函數進行錯誤處理

4.3.1 基本說明

一般情況下，如果傳入的函數不會出現錯誤，可以不進行錯誤處理。但是，如果傳入的函數可能出現錯誤，就必須對其進行錯誤處理，否則可能會導致程序崩潰或出現不可預料的錯誤。

因此，在編寫傳入Once的Do方法的函數時，需要考慮到錯誤處理問題，保證程序的健壯性和穩定性。

4.3.2 未錯誤處理導致的問題

下面舉一個傳入的函數可能出現錯誤，但是沒有對其進行錯誤處理的例子:

import (
   "fmt"
   "net"
   "sync"
)
var (
   initialized bool
   connection  net.Conn
   initOnce    sync.Once
)
func initConnection() {
   connection, _ = net.Dial("tcp", "err_address")
}
func getConnection() net.Conn {
   initOnce.Do(initConnection)
   return connection
}
func main() {
   conn := getConnection()
   fmt.Println(conn)
   conn.Close()
}

在上面例子中，其中initConnection 為傳入的函數，用于建立TCP網絡連接，但是在sync.Once中執行該函數時，是有可能返回錯誤的，而這里并沒有進行錯誤處理，直接忽略掉錯誤。此時調用getConnection 方法,如果initConnection報錯的話，獲取連接時會返回空連接，后續調用將會出現空指針異常。因此，如果傳入sync.Once當中的函數可能發生異常，此時應該需要對其進行處理。

4.3.3 處理方式

• 4.3.3.1 panic退出執行

應用程序第一次啟動時，此時調用sync.Once來初始化一些資源，此時發生錯誤，同時初始化的資源是必須初始化的，可以考慮在出現錯誤的情況下，使用panic將程序退出，避免程序繼續執行導致更大的問題。具體代碼示例如下:

import (
   "fmt"
   "net"
   "sync"
)
var (
   connection  net.Conn
   initOnce    sync.Once
)
func initConnection() {
   // 嘗試建立連接
   connection, err = net.Dial("tcp", "err_address")
    if err != nil {
       panic("net.Dial error")
    }
}
func getConnection() net.Conn {
   initOnce.Do(initConnection)
   return connection
}

如上，當initConnection方法報錯后，此時我們直接panic,退出整個程序的執行。

• 4.3.3.2 修改sync.Once實現，Do函數的語意修改為只成功執行一次

在程序運行過程中，可以選擇記錄下日志或者返回錯誤碼，而不需要中斷程序的執行。然后下次調用時再執行初始化的邏輯。這里需要對sync.Once進行改造，原本sync.Once中Do函數的實現為執行一次，這里將其修改為只成功執行一次。具體使用方式需要根據具體業務場景來決定。下面是其中一個實現:

type MyOnce struct {
   done int32
   m    sync.Mutex
}
func (o *MyOnce) Do(f func() error) {
   if atomic.LoadInt32(&o.done) == 0 {
      o.doSlow(f)
   }
}
func (o *MyOnce) doSlow(f func() error) {
   o.m.Lock()
   defer o.m.Unlock()
   if o.done == 0 {
      // 只有在函數調用不返回err時,才會設置done
      if err := f(); err == nil {
         atomic.StoreInt32(&o.done, 1)
      }
   }
}

上述代碼中，增加了一個錯誤處理邏輯。當 f() 函數返回錯誤時，不會將 done 標記位置為 1，以便下次調用時可以重新執行初始化邏輯。

需要注意的是，這種方式雖然可以解決初始化失敗后的問題，但可能會導致初始化函數被多次調用。因此，在編寫f() 函數時，需要考慮到這個問題，以避免出現不可預期的結果。

下面是一個簡單的例子，使用我們重新實現的Once，展示第一次初始化失敗時，第二次調用會重新執行初始化邏輯，并成功初始化：

var (
   hasCall bool
   conn    net.Conn
   m       MyOnce
)
func initConn() (net.Conn, error) {
   fmt.Println("initConn...")
   // 第一次執行,直接返回錯誤
   if !hasCall {
      return nil, errors.New("init error")
   }
   // 第二次執行,初始化成功,這里默認其成功
   conn, _ = net.Dial("tcp", "baidu.com:80")
   return conn, nil
}
func GetConn() (net.Conn, error) {
   m.Do(func() error {
      var err error
      conn, err = initConn()
      if err != nil {
         return err
      }
      return nil
   })
   // 第一次執行之后,將hasCall設置為true,讓其執行初始化邏輯
   hasCall = true
   return conn, nil
}
func main() {
   // 第一次執行初始化邏輯,失敗
   GetConn()
   // 第二次執行初始化邏輯,還是會執行,此次執行成功
   GetConn()
   // 第二次執行成功,第三次調用,將不會執行初始化邏輯
   GetConn()
}

在這個例子中，第一次調用Do方法初始化失敗了，done標記位被設置為0。在第二次調用Do方法時，由于done標記位為0，會重新執行初始化邏輯，這次初始化成功了，done標記位被設置為1。第三次調用，由于之前Do方法已經執行成功了，不會再執行初始化邏輯。

關于“go并發利器sync.Once如何使用”這篇文章的內容就介紹到這里，感謝各位的閱讀！相信大家對“go并發利器sync.Once如何使用”知識都有一定的了解，大家如果還想學習更多知識，歡迎關注億速云行業資訊頻道。