golang系列之-sync.Once

发表于 更新于 本文字数： 1.3k 阅读时长 ≈ 5 分钟

如果要实现如Singleton、Lazy Initialization模式，那么你需要了解sync.Once，它可以用于保证如：只加载一次配置文件、只初始化一次数据库连接等，此外它还可以帮助实现更好的Plugin封装

当前go版本：1.24

快速上手

以下代码展示了如何使用sync.Once实现singleton模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package main

import (
    "fmt"
    "sync"
    "time"
)

type Singleton struct {
    data string
}

var instance *Singleton
var once sync.Once

func GetInstance() *Singleton {
    once.Do(func() {
        fmt.Println("Creating Singleton instance")
        instance = &Singleton{data: "I'm the only one!"}
    })
    return instance
}

func main() {
    for i := 0; i < 5; i++ {
        go func() {
            fmt.Printf("%p\n", GetInstance())
        }()
    }

    // Wait for goroutines to finish
    time.Sleep(3 * time.Second)
}

数据结构

todo：文章图片待补充

sync.Once的数据结构由一个atomic类型和一个mutex锁组成，通过加锁访问done标志判断

1
2
3
4
5
6
7
8
9
10
11
type Once struct {
    _ noCopy

    // done indicates whether the action has been performed.
    // It is first in the struct because it is used in the hot path.
    // The hot path is inlined at every call site.
    // Placing done first allows more compact instructions on some architectures (amd64/386),
    // and fewer instructions (to calculate offset) on other architectures.
    done atomic.Uint32
    m    Mutex
}

核心方法

Do

Do方法的逻辑如下

  1. 通过CAS原子操作读取done字段数据，如果值是1-已执行则立即返回，否则进入加锁状态
  2. 加锁，执行传入的函数代码，并更新done的数值

原本代码的注释挺有用的，就不再赘述了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


// Do calls the function f if and only if Do is being called for the
// first time for this instance of [Once]. In other words, given
//
//    var once Once
//
// if once.Do(f) is called multiple times, only the first call will invoke f,
// even if f has a different value in each invocation. A new instance of
// Once is required for each function to execute.
//
// Do is intended for initialization that must be run exactly once. Since f
// is niladic, it may be necessary to use a function literal to capture the
// arguments to a function to be invoked by Do:
//
//    config.once.Do(func() { config.init(filename) })
//
// Because no call to Do returns until the one call to f returns, if f causes
// Do to be called, it will deadlock.
//
// If f panics, Do considers it to have returned; future calls of Do return
// without calling f.
func (o *Once) Do(f func()) {
    // Note: Here is an incorrect implementation of Do:
    //
    //    if o.done.CompareAndSwap(0, 1) {
    //        f()
    //    }
    //
    // Do guarantees that when it returns, f has finished.
    // This implementation would not implement that guarantee:
    // given two simultaneous calls, the winner of the cas would
    // call f, and the second would return immediately, without
    // waiting for the first's call to f to complete.
    // This is why the slow path falls back to a mutex, and why
    // the o.done.Store must be delayed until after f returns.

    if o.done.Load() == 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.Load() == 0 {
        defer o.done.Store(1)
        f()
    }
}

其他方法

从1.21版本开始，Austin Clements添加了三个sync.Once的封装：OnceFunc、OnceValue、OnceValues，方便写出更简洁紧凑的代码

OnceFunc

OnceFunc适合无任何返回值的业务逻辑，不适合用作Singleton、Lazy Initialization模式，下面是一个简单的示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main

import (
    "log"
    "sync"
)

func main() {
    onceVoid := func() {
        log.Println("Only once")
    }
    call := sync.OnceFunc(onceVoid)
    for i := 0; i < 10; i++ {
        call()
    }
}

OnceFunc内部实现逻辑如下

  1. 定义状态、封装传入的函数
  2. 只要f执行成功，更新状态，如将valid设置为true（已执行）
  3. 如果f的执行有panic，继续向上抛出异常
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// OnceFunc returns a function that invokes f only once. The returned function
// may be called concurrently.
//
// If f panics, the returned function will panic with the same value on every call.
func OnceFunc(f func()) func() {
    var (
        once  Once
        valid bool
        p     any
    )
    // Construct the inner closure just once to reduce costs on the fast path.
    g := func() {
        defer func() {
            p = recover()
            if !valid {
                // Re-panic immediately so on the first call the user gets a
                // complete stack trace into f.
                panic(p)
            }
        }()
        f()
        f = nil      // Do not keep f alive after invoking it.
        valid = true // Set only if f does not panic.
    }
    return func() {
        once.Do(g)
        if !valid {
            panic(p)
        }
    }
}

OnceValue

一般情况下，我们的业务逻辑使用用OnceValue即可，不够的话，还可以使用OnceValues，下面是使用OnceValue改造后的【快速上手】的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package main

import (
    "fmt"
    "sync"
    "time"
)

type Singleton struct {
    data string
}

// 单例/惰性加载
var instance = sync.OnceValue(func() *Singleton {
    fmt.Println("Creating Singleton instance")
    return &Singleton{data: "I'm the only one!"}
})

func main() {
    for i := 0; i < 5; i++ {
        go func() {
            fmt.Printf("%p\n", instance)
        }()
    }

    // Wait for goroutines to finish
    time.Sleep(3 * time.Second)
}

OnceValue内部实现逻辑与OnceFunc一致，不同的是，内部增加了result字段用于缓存函数的返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// OnceValue returns a function that invokes f only once and returns the value
// returned by f. The returned function may be called concurrently.
//
// If f panics, the returned function will panic with the same value on every call.
func OnceValue[T any](f func() T) func() T {
    var (
        once   Once
        valid  bool
        p      any
        result T
    )
    g := func() {
        defer func() {
            p = recover()
            if !valid {
                panic(p)
            }
        }()
        result = f()
        f = nil
        valid = true
    }
    return func() T {
        once.Do(g)
        if !valid {
            panic(p)
        }
        return result
    }
}

OnceValues

与OnceValue不同的是，OnceValues会返回两个数值，很适合用于加载配置文件、创建数据库连接等。下面代码展示了如何使用OnceValues创建数据库连接

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// https://github.com/golang/go/issues/56102
type Server struct {
    db func() (*sql.DB, error)
}

func NewServer(dbPath string) *Server {
    return &Server{
        db: sync.OnceFunc(func() (*sql.DB, error) {
            return sql.Open("sqlite", dbPath)
        }),
    }
}

func (s *Server) DoSomething() error {
    db, err := s.db()
    if err != nil {
        return err
    }
    _ = db // do something with db
    return nil
}

OnceValues内部实现逻辑与OnceValue一致，不同的是，内部使用的是r1、r2两个字段用于缓存函数的返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// OnceValues returns a function that invokes f only once and returns the values
// returned by f. The returned function may be called concurrently.
//
// If f panics, the returned function will panic with the same value on every call.
func OnceValues[T1, T2 any](f func() (T1, T2)) func() (T1, T2) {
    var (
        once  Once
        valid bool
        p     any
        r1    T1
        r2    T2
    )
    g := func() {
        defer func() {
            p = recover()
            if !valid {
                panic(p)
            }
        }()
        r1, r2 = f()
        f = nil
        valid = true
    }
    return func() (T1, T2) {
        once.Do(g)
        if !valid {
            panic(p)
        }
        return r1, r2
    }
}

参考文档

Understanding Golang’s sync.Once: Practical Examples in 2024
sync: add OnceFunc, OnceValue, OnceValues
Go sync.Once is Simple… Does It Really?