逐步学习Go-sync.Once(只执行一次)Exactly Once

本文主要是介绍逐步学习Go-sync.Once(只执行一次)Exactly Once，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

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) })

COPY

由于 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 intonce := sync.Once{}once.Do(func() {i = 1000})assert.Equal(t, 1000, i)
}func TestOnce_ShouldExecuteOnce_WhenExecutedOnceAndExecuteAgain(t *testing.T) {var i intonce := 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 intonce := sync.Once{}// 第一次调用应该 panicassert.Panics(t, func() {once.Do(func() {panic("Error")})})// 因为第一次panic了，此时再调用 Do 方法，函数 f 不应该被执行once.Do(func() {num = 1000})// 因为 num 的值没有被改变，所以应该还是 0assert.Equal(t, num, 0)
}func TestOnce_ShouldExecuteAgain_WhenPreviousExecutionPaniced(t *testing.T) {var num int = 0once := sync.Once{}// 第一次调用应该 panicassert.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.Int32once := sync.Once{}wg := sync.WaitGroup{}wg.Add(100)// 启动 100 个 goroutine, 都尝试执行once.Dofor i := 0; i < 100; i++ {go func() {once.Do(func() {num.Add(1)})wg.Done()}()}wg.Wait()assert.Equal(t, int32(1), num.Load())
}

COPY

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都会被设置为1defer o.done.Store(1) // 执行用户传入的函数ff()                   }
}

COPY