golang并发安全-sync.Once

什么是sync.Once

sync.Once 是 Go 语言中的一种同步原语，用于确保某个操作或函数在并发环境下只被执行一次。它只有一个导出的方法，即 Do，该方法接收一个函数参数。在 Do 方法被调用后，该函数将被执行，而且只会执行一次，即使在多个协程同时调用的情况下也是如此。

例子

func main() {
	var once sync.Once
	for i := 0; i < 5; i++ {
		go func(i int) {
			fun1 := func() {
				fmt.Printf("i:=%d\n", i)
			}
			once.Do(fun1)
		}(i)
	}
	time.Sleep(1 * time.Second)
}

无论执行多少次，仅返回 i:=0

看看源码

//Once 是一个只执行一次的对象。
//Once 首次使用后不得复制一次。
type Once struct {
    //done表示动作是否已执行。
    // 它在结构中是第一个，因为它在hot路径中使用。
    // 热路径在每个调用站点都是内联的
    done uint32
    m    Mutex
}

唯一的对外开放函数（Do）

func (o *Once) Do(f func()) {
   //one为0则表示未执行过，调用doSlow()方法初始化
	if atomic.LoadUint32(&o.done) == 0 {
		// Outlined slow-path to allow inlining of the fast-path.
		o.doSlow(f)
	}
}

Do(f) 被调用多次，即使f在每次调用中都有不同的值，只有第一次调用才会调用f。

func (o *Once) doSlow(f func()) {
	o.m.Lock()
	defer o.m.Unlock()
	if o.done == 0 { // 双重检查，避免 f 已被执行过
		defer atomic.StoreUint32(&o.done, 1)
		f()
	}
}

只有done == 0 才会被释放，并且使用defer保证 f()执行完会讲done置1

我们说说Once一些其他的事吧

不要嵌套同一个once

func main() {
	var once sync.Once
	for i := 0; i < 5; i++ {
		once.Do(func() {
			once.Do(func() {
				fmt.Println(1)
			})
		})
	}
	time.Sleep(1 * time.Second)
}

直接报错：

作者在代码中提示我们：因为在对f的一个调用返回之前，不会返回对Do的调用，所以如果f导致调用Do，它将死锁。

解释 atomic.CompareAndSwapUint32 为什么不行

作者提到了 atomic.CompareAndSwapUint32 是存在问题：给定两个同时调用，cas的获胜者将调用f，第二个将立即返回，而无需等待第一个对f的调用完成。

func (o *Once) Do(f func()) {
	if atomic.CompareAndSwapUint32(&o.done, 0, 1) {
		f()
	}
}

虽然 cas 保证了同一时刻只有一个请求进入 if 判断执行 f()。但是其它的请求却没有等待 f() 执行完成就立即返回了。那么用户端在执行 once.Do 返回之后其实就可能存在 f() 还未完成，就会出现意料之外的错误。如下面例子

type OnceSelf struct {
	done uint32
}

func (o *OnceSelf) Do(f func()) {

	if atomic.CompareAndSwapUint32(&o.done, 0, 1) {f() }
}

func main() {
	var b map[string]int
	var once OnceSelf
	go func() {
		once.Do(func() {
			b = make(map[string]int, 10)
		})
	}()
	b["1"] = 1
	fmt.Println(b)

}

会存在问题