sync.Once简介
sync.Once 是一个会执行且仅执行一次动作的对象。该对象在第一次使用后不能再被复制。
在 Go 内存模型的术语中，sync.Once 的 Do 方法中的函数 f 返回的操作，相对于任何对 once.Do(f) 的调用返回的操作，都具有“同步优先”的顺序。简单来说，即使在并发环境下，函数 f 也只会在首次调用 once.Do(f) 时执行。
每个 sync.Once 对象仅适用于执行一次动作。也就是说，如果多次调用了 once.Do(f)，仅第一次的调用会激发函数 f 的执行，即使每次调用 once.Do(f) 时函数 f 的值都有所不同。
sync.Once 一般用于必须仅初始化一次的场景。由于作为 Do 方法参数的函数没有传入的参数，如果你需要在由 Do 方法调用的函数中使用特定的参数，你可能需要使用闭包：
config.once.Do(func() { config.init(filename) })由于 Do 方法在其内部的函数返回之前不会返回，如果函数 f 导致 Do 方法被调用，就会引发死锁。
如果 Do 方法的函数 f 发生 panic，sync.Once 会认为函数 f 已执行完毕。以后再调用 Do 方法时，不会再执行函数 f。
功能特性测试
sync.Once还是比较简单的，而且源代码也特别简单，我们来列举几个场景测试。
以下是每个测试用例所覆盖的特性和场景的描述：
-
TestOnce_ShouldExecuteOnce_WhenExecuteOnlyOnce：这个测试用例验证了sync.Once的基本特性 – 即确保一段代码在非并发环境中只执行一次。 -
TestOnce_ShouldExecuteOnce_WhenExecutedOnceAndExecuteAgain：这个测试用例验证了即使sync.Once的Do方法被多次调用，内部的函数也只执行一次。这是sync.Once的核心特性，用于确保一个操作在整个程序运行期间只执行一次，无论这个操作被尝试执行多少次。 -
TestOnce_ShouldNotExecute_WhenFunctionPanicked：这个测试用例验证了当sync.Once的Do方法的函数执行过程中发生panic时，随后的Do调用将不会继续执行函数。这是sync.Once的一个重要特性，它确保了即使在面临错误处理的情况下，被追踪的函数只执行一次。 -
TestOnce_ShouldExecuteAgain_WhenPreviousExecutionPaniced：这个测试用例验证了即使Do方法的函数因为panic而没有正常执行，sync.Once也会认为该函数已经执行过，并且不会在后续的Do方法调用中再次尝试执行函数。这是sync.Once的另一个重要特性，它可以帮助规避错误以及异常的发生。 -
TestOnce_ShouldExecuteOnce_WhenCalledInMultipleGoroutines：这个测试用例验证了即使在多个goroutine并发调用sync.Once的Do方法时，函数也只会执行一次。这是sync.Once被设计用来解决的主要问题，也是sync.Once在并发编程中的一个重要应用场景。
测试代码
import (
"sync"
"sync/atomic"
"testing"
"github.com/stretchr/testify/assert"
)
func TestOnce_ShouldExecuteOnce_WhenExecuteOnlyOnce(t *testing.T) {
var i int
once := sync.Once{}
once.Do(func() {
i = 1000
})
assert.Equal(t, 1000, i)
}
func TestOnce_ShouldExecuteOnce_WhenExecutedOnceAndExecuteAgain(t *testing.T) {
var i int
once := sync.Once{}
once.Do(func() {
i = 1000
})
once.Do(func() {
i = 2000
})
assert.Equal(t, 1000, i)
}
func TestOnce_ShouldNotExecute_WhenFunctionPanicked(t *testing.T) {
var num int
once := sync.Once{}
// 第一次调用应该 panic
assert.Panics(t, func() {
once.Do(func() {
panic("Error")
})
})
// 因为第一次panic了，此时再调用 Do 方法，函数 f 不应该被执行
once.Do(func() {
num = 1000
})
// 因为 num 的值没有被改变，所以应该还是 0
assert.Equal(t, num, 0)
}
func TestOnce_ShouldExecuteAgain_WhenPreviousExecutionPaniced(t *testing.T) {
var num int = 0
once := sync.Once{}
// 第一次调用应该 panic
assert.Panics(t, func() {
once.Do(func() {
panic("Error")
})
})
// 第一次 panic 后，下一次调用应该正确执行
once.Do(func() {
num = 1000
})
assert.Equal(t, 0, num)
}
func TestOnce_ShouldExecuteOnce_WhenCalledInMultipleGoroutines(t *testing.T) {
var num atomic.Int32
once := sync.Once{}
wg := sync.WaitGroup{}
wg.Add(100)
// 启动 100 个 goroutine, 都尝试执行once.Do
for i := 0; i < 100; i++ {
go func() {
once.Do(func() {
num.Add(1)
})
wg.Done()
}()
}
wg.Wait()
assert.Equal(t, int32(1), num.Load())
}
sync.Once源码
type Once struct {
// 用来标识操作是否已经执行过
done atomic.Uint32
// 用来在多个并发的`Do`调用中，保证只有一个可以执行函数`f`
m Mutex
}
func (o *Once) Do(f func()) {
if o.done.Load() == 0 {
// 如果操作还没执行过，进入doSlow方法
o.doSlow(f)
}
}
func (o *Once) doSlow(f func()) {
o.m.Lock()
defer o.m.Unlock()
if o.done.Load() == 0 {
// 确保无论f是否panic，done都会被设置为1
defer o.done.Store(1)
// 执行用户传入的函数f
f()
}
}sync.Once能用来干啥？
- 单例模式
- 延迟初始化
- 并发控制