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还是比较简单的，而且源代码也特别简单，我们来列举几个场景测试。
以下是每个测试用例所覆盖的特性和场景的描述：

1. TestOnce_ShouldExecuteOnce_WhenExecuteOnlyOnce：这个测试用例验证了sync.Once的基本特性 – 即确保一段代码在非并发环境中只执行一次。

2. TestOnce_ShouldExecuteOnce_WhenExecutedOnceAndExecuteAgain：这个测试用例验证了即使sync.Once的Do方法被多次调用，内部的函数也只执行一次。这是sync.Once的核心特性，用于确保一个操作在整个程序运行期间只执行一次，无论这个操作被尝试执行多少次。

3. TestOnce_ShouldNotExecute_WhenFunctionPanicked：这个测试用例验证了当sync.Once的Do方法的函数执行过程中发生panic时，随后的Do调用将不会继续执行函数。这是sync.Once的一个重要特性，它确保了即使在面临错误处理的情况下，被追踪的函数只执行一次。

4. TestOnce_ShouldExecuteAgain_WhenPreviousExecutionPaniced：这个测试用例验证了即使Do方法的函数因为panic而没有正常执行，sync.Once也会认为该函数已经执行过，并且不会在后续的Do方法调用中再次尝试执行函数。这是sync.Once的另一个重要特性，它可以帮助规避错误以及异常的发生。

5. 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能用来干啥？

1. 单例模式
2. 延迟初始化
3. 并发控制