「Golang」sync.Once用法以及源码讲解

前言

在我们开发过程中经常会使用到单例模式这一经典的设计模式，单例模式可以帮助开发者针对某个（些）变量或者对象或者函数（方法）进行在程序运行期间只有一次的初始化或者函数调用操作，比如在开发项目中针对某一类连接池的初始化（如数据库连接池等）。针对这种情况，我们就需要使用单例模式进行操作。

单例模式🌰

自己搞得单例模式

要实现一个单例模式，我们会很快就想到了在一个结构体中放置一个flag字段用于标记当前的函数是否被执行过，举个🌰：

  1. type SingletonPattern struct {
  2.     done bool
  3. }
  5. func (receiver *SingletonPattern) Do(f func())  {
  6.     if !receiver.done {
  7.         f()
  8.         receiver.done=true
  9.     }
  10. }

看似很美好，但是此时，如果传入的需要调用的函数f()会执行很长时间，比如数据库查询或者做一些连接什么的，当别的goroutine运行到此处的时候由于还没有执行完f()，就会发现done标记仍然是false，那么仍然会调用一次f()，此时就违背了单例模式的初衷。

那么如何解决上面的并发的问题呢。此时就可以使用go标准库中所提供的并发原语—-sync.Once

标准库真香系列之sync.Once

话不多说先上sync.Once 结构体的源代码：

  1. type Once struct {
  2.     // 标记符号，用于标记是否执行过
  3.     done uint32
  4.     // 互斥锁，用于保护并发调用以及防止copy
  5.     m    Mutex
  6. }

结构体就这么简单，字段done用于标记是否执行过函数，至于为什么使用uint32类型，作者的理解是为了之后使用atomic操作做的妥协，m字段值用于保护并发情况下的情形，并且由于继承了Locker接口可以通过vet校验到其是否被复制

接下来看一下用于执行函数调用的Do()函数的实现：

  1. func (o *Once) Do(f func()) {
  2.     // 原子获取当前 done 字段是否等于0
  3.     // 如果当前字段等于1 
  4.     // 则代表已经 执行过
  5.     // 这是第一层校验
  6.     if atomic.LoadUint32(&o.done) == 0 {
  7.     // 如果为0则代表没被调用过则调用
  8.     // 此处写成一个函数的原因是为了
  9.     // 进行函数内联提升性能
  10.         o.doSlow(f)
  11.     }
  12. }
  14. func (o *Once) doSlow(f func()) {
  15.     // 此处加锁用于防止其他goroutine同时访问调用
  16.     o.m.Lock()
  17.     defer o.m.Unlock()
  18.     // 二次校验
  19.     // 为的是防止多个goroutine进入此函数的时候，可能发生的重复执行 f()
  20.     if o.done == 0 {
  21.         // 函数执行结束设置done 字段为 1代表已经执行完毕
  22.         defer atomic.StoreUint32(&o.done, 1)
  23.         // 执行
  24.         f()
  25.     }
  26. }

此时，sync.Once 的所有源代码已经解析完毕了（惊不惊喜，意不意外），其实sync.Once 的过程很简单，就是根据标记进行双重判断确定函数是否执行过，没执行就执行，执行了就跳过。

sync.Once 的使用问题

哪来的deadlock？

sync.Once 的确很简单，使用也很简单，但是还是会有使用上可能出现的一些问题比如下列代码：

  1. func main() {
  2.     var once sync.Once
  3.     once.Do(
  4.         func() {
  5.             fmt.Println("one once do")
  6.             once.Do(
  7.                 func() {
  8.                     fmt.Println("second once do")
  9.                 })
  10.         })
  11. }

该代码会出现什么问题？答案是：

fatal error: all goroutines are asleep - deadlock!

为什么会这样？因为内层个Do是被外层的同一个once对象所调用，由于此时已经进入了第一个Do并且已经调用了函数，那么此时sync.Once 中的互斥锁字段，已经被加了锁，此时二次加锁就会产生死锁。因此使用sync.Once 最重要的一点就是：*

不要在执行函数中，嵌套当前的sync.Once 对象 不要在执行函数中，嵌套当前的sync.Once 对象 不要在执行函数中，嵌套当前的sync.Once 对象。（重要的话要说三遍）

哪来的invalid memory address or nil pointer dereference？

看一下下面的代码：

  1. func main() {
  2.     var once sync.Once
  3.     var conn net.Conn
  4.     once.Do(
  5.         func() {
  6.             var err error
  7.             conn, err = net.Dial("tcp", "")
  8.             if err != nil {
  9.                 return
  10.             }
  11.         })
  12.     conn.RemoteAddr()
  13. }

在运行时，会出现：

panic: runtime error: invalid memory address or nil pointer dereference

为什么？因为sync.Once只保证执行一次，但是不保证执行是否出错，即我只管调用，出错了跟我无关，上述代码中

  1. conn, err = net.Dial("tcp", "")

必定出现err!=nil的情况，此时如果不对conn变量进行判断为nil，就会出现空指针异常，那么，如何来保证他执行成功了呢，我们需要对其进行改造

  1. type Once struct {
  2.     once sync.Once
  3. }
  5. func (receiver *Once) OnceDo(f func() error) error {
  6.     var err error
  7.     receiver.once.Do(
  8.         func() {
  9.             err = f()
  10.         })
  11.     return err
  12. }
  14. func main() {
  15.     var once Once
  16.     var conn net.Conn
  17.     err := once.OnceDo(
  18.         func() error {
  19.             var err error
  20.             conn, err = net.Dial("tcp", "")
  21.             if err != nil {
  22.                 return err
  23.             }
  24.             return nil
  25.         })
  26.     if err != nil {
  27.         log.Fatal(err)
  28.     }
  29. }

经过封装，我们就可以得到sync.Once 执行时是否出错，以适配各种错误处理。

此封装可能会有更好的解决方案，上面的方案也仅仅是一个🌰罢了。

总结

至此sync.Once 的用法以及源码解析就完成了，可能有些地方有些理解上的错误，请各位谅解并且帮忙指出修改意见，如果这篇文章能帮到你，这是我的荣幸。