Go 并发原语之简约的 Once

Go 并发系列是根据我对晁岳攀老师的《Go 并发编程实战课》的吸收和理解整理而成，如有偏差，欢迎指正~

本文大纲



Once 是什么

Once 是 Go 内置库 sync 中一个比较简单的并发原语。顾名思义，它的作用就是执行那些只需要执行一次的动作。

Once 的使用场景

Once 最典型的使用场景就是单例对象的初始化。

在 MySQL 或者 Redis 这种频繁访问数据的场景中，建立连接的代价远远高于数据读写的代价，因此我们会用单例模式来实现一次建立连接，多次访问数据，从而实现提升服务性能。

常见的单例写法如下：

package mainimport (    "net"    "sync"    "time")// 使用互斥锁保证线程(goroutine)安全var connMu sync.Mutexvar conn net.Connfunc getConn() net.Conn {    connMu.Lock()    defer connMu.Unlock()    // 返回已创建好的连接    if conn != nil {        return conn    }    // 创建连接    conn, \_ = net.DialTimeout("tcp", "baidu.com:80", 10\*time.Second)    return conn}// 使用连接func main() {    conn := getConn()    if conn == nil {        panic("conn is nil")    }}

这个例子中，在创建 tcp 连接的时候，使用了单例模式。使用单例模式的注意点是建立连接的时候，需要对这个过程加锁。

单例模式有个问题，每次都会进行加锁、解锁操作，对性能的消耗比较大，而 Once 可以解决这个问题。

Once 除了 用来初始化单例资源，应用场景还有并发访问只需初始化一次的共享资源，或者在测试的时候初始化一次测试资源。

总之，凡是只需要初始化一次的资源，都可以用 Once。

Once 如何使用

Once 的使用很简单，只有一个对外暴露 Do(f func()) 方法，参数是函数。Do 函数只要被调用过一次，之后无论怎么调用，参数怎么变化，都不会生效。

所以，对于上文的例子，如果我们使用 Once，要怎么写呢？

示例代码如下：

package mainimport (    "net"    "sync"    "time")var conn net.Connvar once sync.Oncefunc getConn() net.Conn {    once.Do(func() {        // 创建连接    conn, \_ = net.DialTimeout("tcp", "baidu.com:80", 10\*time.Second)    })    return conn}// 使用连接func main() {    conn := getConn()    if conn == nil {        panic("conn is nil")    }}

在这段代码中，我们通过 once.Do() 实现了前面的单例模式。

这里面三点需要注意，一是 once 的作用域和资源变量 conn 的作用域要保持一致；二是对于同一个 once，仅第一次 Do(f) 中的 f 会被执行，第二次哪怕换成 Do(f1)，f1 也不会被执行；三是 Do(f) 的参数 f 是一个无参数无返回值的函数。

第一点比较好理解，如果 once 的作用域只在某个函数中生效，显然是可以在多个函数中执行 once.Do() 的。

第二点强调的是，once.Do() 只生效一次指的是 Do() 函数只会执行一次，不会区分参数中的函数 f。

第三点 f 是无参数无返回值的函数。如果有参数要怎么处理呢？你可以将参数改成全局变量，或者用闭包实现 once.Do()，像这样：

func closureF(x int ) func() {    return func() {        fmt.Println(x)    }}func main() {    var once sync.Once    x := 4    once.Do(closureF(x))}

Once 的实现原理

Once 实现的功能很简单，因此很多人会想当然的认为很容易实现。

一开始我也这么想的。。

比如，通过一个全局变量来做标记，执行过一次 Do 函数，就修改标记的状态，之后再执行的时候根据标记的状态来决定是否需要真正执行函数。

这种做法有个很大的问题，如果 Do(f) 中 f 执行速度很慢，标记位的状态已经被修改了，后来的 goroutine 就会以为资源初始化已经完成，但是实际上啥也获取不到。

下面让我们看一看 Once 到底是如何实现的。

Once 实现源码

type Once struct {    done uint32    m    Mutex}func (o \*Once) Do(f func()) {    if atomic.LoadUint32(&o.done) == 0 {        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()    }}

先看 Once 的结构体定义：一个 done 标志位 + 一个锁。done 用来记录资源初始化是否完成，锁用来保证同一时刻，只能有一个 goroutine 进行资源的初始化。

由于这里使用了 done 标志位，锁只有在资源初始化的时候才会调用，其它时候并不会调用，因此性能相比单例模式的原始写法，要高不少。

再看 Do() 函数的实现。这里使用了函数内联的方式，只有发现 done 是 0 的情况下，才会执行 doSlow() 函数。

doSlow() 中又再次检查了 done 的值，这就是双检查机制。并发场景下，done 值的检查和修改必须先持有锁才行。

整体看，Once 的实现还是比较简单的。在实践中，很少会出现 Once 使用错误的情况，但是有两种场景，还是要特殊注意下。

使用 Once 的 2 种错误

死锁

由于 Once 的定义中有互斥锁，如果出现 once.Do(f) 执行 f，f再执行 once.Do(f) 的场景，就出现了类似重入的现象，造成死锁，比如下面：

func main() {    var once sync.Once    once.Do(func() {        once.Do(func() {            fmt.Println("初始化")        })    })}

这种情况下，m.Lock 等待 m.Lock，形成了死锁。要避免这种情况，只要 f 中不执行 once.Do() 就行。

初始化失败

如果 f 执行异常，资源初始化失败，Once 还是会认为执行成功，而再次执行 Do(f) 的时候，f 也不会再被执行，导致接下来直接使用初始化的资源时候异常。

这种情况下该如何处理呢？

可以自己实现一个类似的 Once 原语！！ 只有当资源初始化成功，done 的值才置成 1， 否则不变。

当然，还有一点需要注意的是，自定义 Once 的结构体中，需要再加一个标志表明是否初始化成功，否则如果初始化失败，再继续后面的流程，很容易出现 panic。

码农的自由之路

996的码农，也能自由~

47篇原创内容

公众号

---

都看到这里了，不如点个 赞/在看？