GoLang中的sync包Once使用执行示例

背景

在系统初始化的时候，某些代码只想被执行一次，这时应该怎么做呢，没有学习 Once 前，大家可能想到 声明一个标识，表示是否初始化过，然后初始化这个标识加锁，更新这个标识。

但是学会了 One 的使用可以更加简单的解决这个问题

One简介

Once 包主要用于在并发执行代码的时候，某部分代码只会被执行 一次。

Once 的使用也非常简单，Once 只有一个 Do 方法，接收一个无参数无返回值的函数类型的参数 f，不管调用多少次 Do 方法，参数 f 只在第一次调用 Do 方法时执行。

示例

我们有一个Msg 参数，多个协程都会用到他，但是这个参数只用初始化一次就可以。

package main
import (
	"fmt"
	"sync"
	"time"
)
var msg string
func main() {
	var one sync.Once
	for i := 0; i < 5; i++ {
		go func(i int) {
			one.Do(func() { 
				fmt.Printf("%d 执行初始化！\n", i)
				msg = "Your Need Data"
			})
			fmt.Println(msg)
		}(i)
	}
	time.Sleep(3* time.Second)
}

执行结果如下：

可以看到初始化的代码只被4号线程执行了一次， 其他协程都是直接读的初始化的数据，并没有执行初始化的函数。

注意

不要在 Do() 方法的参数方法中再次调用Do() 方法，因为执行这个Do() 方法的参数方法的时候，One 会持有一个锁，如果再参数方法中再次调用Do() 方法，就会等待这个锁释放， 导致参数方法无法执行完毕，然后外层的Do 方法就一直无法释放锁，最后就成了死锁。

错误示例：

package main
import (
	"fmt"
	"sync"
)
var msg string
var one sync.Once
func main() {
	one.Do(fun1)
}
func fun1(){
	fmt.Println("我是 fun1")
	one.Do(fun2)
}
func fun2(){
	fmt.Println("我是 fun2")
}

执行结果：

可以知道再 fun1() 中使用 Do() 方法调用 fun2 的时候形成了死锁， 因为在 fun1() 执行过程中已将持有了该锁，需要 fun1() 执行完毕才会释放，然后因为使用 Do() 方法执行 fun2() 也会请求这个锁， 会一直等待，导致 fun1() 不可能执行完， 也不可能释放锁。成了死锁。

源码解读

查看源码

func (o *Once) Do(f func()) {
	if atomic.LoadUint32(&o.done) == 0 {
		// Outlined slow-path to allow inlining of the fast-path.
		o.doSlow(f)
	}
}
func (o *Once) doSlow(f func()) {
	o.m.Lock()
	defer o.m.Unlock()
	if o.done == 0 {
		defer atomic.StoreUint32(&o.done, 1)
		f()
	}
}

使用一个原子类作为标识，加锁校验和操作原子类，保证只会被一个协程执行。

Do 调用了 doSlow ， 在 doSlow 中有defer 关键字，表示执行函数和释放锁是倒序执行，必须先执行完毕 if 判断和里面的 f() 才能释放锁。