[Golang] 初探之 sync.Once
阿新 • • 發佈:2021-10-23
# 描述
sync.Once是 Golang package 中使方法只執行一次的物件實現,作用與init函式類似。但也有所不同。
- init函式是在檔案包首次被載入的時候執行,且只執行一次
- sync.Onc是在程式碼執行中需要的時候執行,且只執行一次
當一個函式不希望程式在一開始的時候就被執行的時候,我們可以使用sync.Once。
例如:
package main
import (
"fmt"
"sync"
)
func main() {
var once sync.Once
onceBody := func() {
fmt.Println("Only once")
}
done := make(chan bool)
for i := 0; i < 10; i++ {
go func() {
once.Do(onceBody)
done <- true
}()
}
for i := 0; i < 10; i++ {
<-done
}
}
# Output:
Only once
sync.Once使用變數done來記錄函式的執行狀態,使用sync.Mutex和sync.atomic來保證執行緒安全的讀取done。
# 原始碼
package sync
import (
"sync/atomic"
)
// Once is an object that will perform exactly one action.
type Once struct {
m Mutex
done uint32
}
// Do calls the function f if and only if Do is being called for the
// first time for this instance of Once. In other words, given
// var once Once
// if once.Do(f) is called multiple times, only the first call will invoke f,
// even if f has a different value in each invocation. A new instance of
// Once is required for each function to execute.
//
// Do is intended for initialization that must be run exactly once. Since f
// is niladic, it may be necessary to use a function literal to capture the
// arguments to a function to be invoked by Do:
// config.once.Do(func() { config.init(filename) })
//
// Because no call to Do returns until the one call to f returns, if f causes
// Do to be called, it will deadlock.
//
// If f panics, Do considers it to have returned; future calls of Do return
// without calling f.
//
func (o *Once) Do(f func()) {
if atomic.LoadUint32(&o.done) == 1 {
return
}
// Slow-path.
o.m.Lock()
defer o.m.Unlock()
if o.done == 0 {
defer atomic.StoreUint32(&o.done, 1)
f()
}
}