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

内容目录

sync.Once简介

sync.Once 是一个会执行且仅执行一次动作的对象。该对象在第一次使用后不能再被复制。

在 Go 内存模型的术语中,sync.OnceDo 方法中的函数 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.OnceDo方法被多次调用,内部的函数也只执行一次。这是sync.Once的核心特性,用于确保一个操作在整个程序运行期间只执行一次,无论这个操作被尝试执行多少次。

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

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

  5. TestOnce_ShouldExecuteOnce_WhenCalledInMultipleGoroutines:这个测试用例验证了即使在多个goroutine并发调用sync.OnceDo方法时,函数也只会执行一次。这是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. 并发控制

发表评论

您的电子邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部