Once函数单次调用

 1package main
 2
 3import (
 4    "fmt"
 5    "sync"
 6)
 7
 8//婷婷的淘宝客户端和web端都会指向婷婷这一个人
 9type Woman struct {
10    name string
11}
12
13var (
14    once sync.Once
15    ting *Woman
16)
17
18func getTing() *Woman {
19    once.Do(func() {
20        ting = new(Woman)
21        ting.name = "tingting"
22        fmt.Println("newtingting")
23    })
24    fmt.Println("gettingting")
25    return ting
26}
27
28func main() {
29    for i := 0; i < 3; i++ {
30        _ = getTing()
31    }
32}

1newtingting
2gettingting
3gettingting
4gettingting

1type Once struct {
2    // done indicates whether the action has been performed.
3    // It is first in the struct because it is used in the hot path.
4    // The hot path is inlined at every call site.
5    // Placing done first allows more compact instructions on some architectures (amd64/x86),
6    // and fewer instructions (to calculate offset) on other architectures.
7    done uint32
8    m    Mutex
9}

 1func (o *Once) Do(f func()) {
 2    // Note: Here is an incorrect implementation of Do:
 3    //
 4    //  if atomic.CompareAndSwapUint32(&o.done, 0, 1) {
 5    //      f()
 6    //  }
 7    //
 8    // Do guarantees that when it returns, f has finished.
 9    // This implementation would not implement that guarantee:
10    // given two simultaneous calls, the winner of the cas would
11    // call f, and the second would return immediately, without
12    // waiting for the first's call to f to complete.
13    // This is why the slow path falls back to a mutex, and why
14    // the atomic.StoreUint32 must be delayed until after f returns.
15
16    if atomic.LoadUint32(&o.done) == 0 {
17        // Outlined slow-path to allow inlining of the fast-path.
18        o.doSlow(f)
19    }
20}
21
22func (o *Once) doSlow(f func()) {
23    o.m.Lock()
24    defer o.m.Unlock()
25    if o.done == 0 {
26        defer atomic.StoreUint32(&o.done, 1)
27        f()
28    }
29}