sync.Once

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

// Once is an object that will perform exactly one action.
//
// A Once must not be copied after first use.
type Once struct {
    // 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 表示操作是否已经执行。
    // 它在结构体中位于首位，因为它在 hot path 中使用。
    // hot path 内联在每个调用点。
    // 在某些体系结构上(amd64/386)，将done放在第一位可以让指令更紧凑，而在其他体系结构上可以让指令更少(用于计算偏移量)。
    done uint32		// 0.未被调用过 1.已被调用过
    m    Mutex		// 互斥锁
}

// 其中解释了为什么将 done 置为 Once 的第一个字段：done 在热路径中，done 放在第一个字段，能够减少 CPU 指令，也就是说，这样做能够提升性能。
//  1. 热路径(hot path)是程序非常频繁执行的一系列指令，sync.Once 绝大部分场景都会访问 o.done，在热路径上是比较好理解的，
//	如果 hot path 编译后的机器码指令更少，更直接，必然是能够提升性能的。
//  2. 为什么放在第一个字段就能够减少指令呢？因为结构体第一个字段的地址和结构体的指针是相同的，如果是第一个字段，直接对结构体的指针解引用即可。
//  如果是其他的字段，除了结构体指针外，还需要计算与第一个值的偏移(calculate offset)。在机器码中，偏移量是随指令传递的附加值，
//  CPU 需要做一次偏移值与指针的加法运算，才能获取要访问的值的地址。因为，访问第一个字段的机器代码更紧凑，速度更快。

 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

// 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 atomic.CompareAndSwapUint32(&o.done, 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 atomic.StoreUint32 must be delayed until after f returns.
    //
    // 注意:下面是一个不正确的Do实现。
    //  以下形式不能保证Do函数返回时f函数已执行完，因为我们是先标记后执行f的。
    //  if atomic.CompareAndSwapUint32(&o.done, 0, 1) {
    //      f()
    //  }
    // 
    // Do 保证当它返回时，f 已经完成
    // 这种实现不会实现这种保证:给定两个同时调用，cas的赢家将调用f，而第二个将立即返回，而无需等待第一个调用完成。
    // 这就是慢路径回退到互斥量的原因，也是原子性的原因。StoreUint32必须延迟到f返回之后。

    // 后续大部分情况会从这里判断失败
    if atomic.LoadUint32(&o.done) == 0 {
        // Outlined slow-path to allow inlining of the fast-path.
        o.doSlow(f)
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

func (o *Once) doSlow(f func()) {
    o.m.Lock() // 获取锁
    defer o.m.Unlock() // 延迟释放锁
    // 当出现并发时，这里会拦住等待着的协程
    if o.done == 0 {	
        // 在f()执行完后才会标记done为1。
        defer atomic.StoreUint32(&o.done, 1)
        // 需要保证f函数不会发生panic
        // 如果发生panic，则o.done会被标记为1，后续不会在调用f函数
        f()
    }
}

 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

type Config struct {
    Server string
    Port   int64
}

var (
    once   sync.Once
    config *Config
)

func ReadConfig() *Config {
    once.Do(func() {
        var err error
        config = &Config{Server: os.Getenv("TT_SERVER_URL")}
        config.Port, err = strconv.ParseInt(os.Getenv("TT_PORT"), 10, 0)
        if err != nil {
            config.Port = 8080 // default port
        }
        log.Println("init config")
    })
    return config
}

func main() {
    for i := 0; i < 10; i++ {
        go func() {
            _ = ReadConfig()
        }()
    }
    time.Sleep(time.Second)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

var populateMapsOnce sync.Once
var entity           map[string]rune

func populateMaps() {
    entity = map[string]rune{
        "AElig;":                           '\U000000C6',
        "AMP;":                             '\U00000026',
        "Aacute;":                          '\U000000C1',
        "Abreve;":                          '\U00000102',
        "Acirc;":                           '\U000000C2',
        // 省略 2000 项
    }
}

func UnescapeString(s string) string {
    populateMapsOnce.Do(populateMaps)
    i := strings.IndexByte(s, '&')

    if i < 0 {
            return s
    }
    // 省略后续的实现
}

 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"
)

var once sync.Once

func onces() {
    fmt.Println("once")
}

func onced() {
    fmt.Println("onced")
}

func main() {
    for i, v := range make([]string, 10){
        once.Do(onces)
        fmt.Println("v:", v, "--i:", i)
    }

    for i := 0; i < 10; i++ {
        go func(i int) {
            once.Do(onced)
            fmt.Println(i)
        }(i)
    }

    time.Sleep(3 * time.Second)
}