深度解析Golang sync.Once源码

目录

• 什么是sync.Once
• 如何使用sync.Once
• 源码分析

文章始发于公众号【迈莫coding】 https://mp.weixin.qq.com/s/b89PmljELaPaVuLw-YIQKg

什么是sync.Once

Once 能够用来执行且仅仅执行一次动做，经常用于单例对象的初始化场景。

Once 经常用来初始化单例资源，或者并发访问只需初始化一次的共享资源，或者在测试的时候初始化一次测试资源。

sync.Once 只暴露了一个方法 Do，你能够屡次调用 Do 方法，可是只有第一次调用 Do 方法时 f 参数才会执行，这里的 f 是一个无参数无返回值的函数。

如何使用sync.Once

就拿我负责的一个项目来讲，由于项目的配置是挂在第三方平台上，因此在项目启动时须要获取资源配置，由于须要一个方法来保证配置仅此只获取一次，所以，咱们考虑使用 sync.Once 来获取资源。这样的话，能够防止在其余地方调用获取资源方法，该方法仅此执行一次。

下面我简单写个Demo来演示一个sync.Once如何使用

package main
import (
   "fmt"
   "sync"
)
var once sync.Once
var con string
func main() {
   once.Do(func() {
      con = "hello Test once.Do"
   })
   fmt.Println(con)
}

代码说明：

代码的话比较简单，就是经过调用Do方法，采用闭包方式，将字符串("hello Test once.Do")赋值给con，进而打印出值，这就是 sync.Once 的使用，比较容易上手。

但咱们用一个方法或者框架时，若是不对其了如指掌，总有点不太靠谱，感受内心不踏实。为此，咱们来聊一聊 sync.Once 的源码实现，让他无处可遁。

源码分析

接下来分析 sync.Do 到底是如何实现的，它存储在包sync下 once.go 文件中，源代码以下:

// sync/once.go

type Once struct {
   done uint32 // 初始值为0表示还未执行过，1表示已经执行过
   m    Mutex 
}
func (o *Once) Do(f func()) {
   // 判断done是否为0，若为0，表示未执行过，调用doSlow()方法初始化
   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()
   // 采用双重检测机制 加锁判断done是否为零
   if o.done == 0 {
      // 执行完f()函数后，将done值设置为1
      defer atomic.StoreUint32(&o.done, 1)
      // 执行传入的f()函数
      f()
   }
}

接下来会分为两大部分进行分析，第一部分为 Once 的结构体组成结构，第二部分为 Do 函数的实现原理，我会在代码上加上注释，保证用心阅读完都有收获。

结构体

type Once struct {
   done uint32 // 初始值为0表示还未执行过，1表示已经执行过
   m    Mutex 
}

首先定义一个struct结构体 Once ，里面存储两个成员变量，分别为 done 和 m 。

done成员变量

• 1表示资源未初始化，须要进一步初始化
• 0表示资源已初始化，无需初始化，直接返回便可

m成员变量

• 为了防止多个goroutine调用 doSlow() 初始化资源时，形成资源屡次初始化，所以采用 Mutex 锁机制来保证有且仅初始化一次

Do

func (o *Once) Do(f func()) {
   // 判断done是否为0，若为0，表示未执行过，调用doSlow()方法初始化
   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()
   // 采用双重检测机制 加锁判断done是否为零
   if o.done == 0 {
      // 执行完f()函数后，将done值设置为1
      defer atomic.StoreUint32(&o.done, 1)
      // 执行传入的f()函数
      f()
   }

调用 Do 函数时，首先判断done值是否为0，若为1，表示传入的匿名函数 f() 已执行过，无需再次执行；若为0，表示传入的匿名函数 f() 还未执行过，则调用 doSlow() 函数进行初始化。

在 doSlow() 函数中，若并发的goroutine进入该函数中，为了保证仅有一个goroutine执行 f() 匿名函数。为此，须要加互斥锁保证只有一个goroutine进行初始化，同时采用了双检查的机制(double-checking)，再次判断 o.done 是否为 0，若是为 0，则是第一次执行，执行完毕后，就将 o.done 设置为 1，而后释放锁。

即便此时有多个 goroutine 同时进入了 doSlow 方法，由于双检查的机制，后续的 goroutine 会看到 o.done 的值为 1，也不会再次执行 f。

这样既保证了并发的 goroutine 会等待 f 完成，并且还不会屡次执行 f。

文章也会持续更新，能够微信搜索「 迈莫coding 」第一时间阅读。天天分享优质文章、大厂经验、大厂面经，助力面试，是每一个程序员值得关注的平台。