package main

import (
    "fmt"
    "sync"
)


// 數(shù)據(jù)庫配置
type Config struct {
    Server string
    Port   int
}

var (
    once   sync.Once
    config *Config
)


// 初始化數(shù)據(jù)庫配置
func InitConfig() *Config {
    once.Do(func() {
        fmt.Println("mock init ...") // 模擬初始化代碼
    })

    return config
}

func main() {
    // 連續(xù)調(diào)用 5 次初始化方法
    for i := 0; i < 5; i++ {
        _ = InitConfig()
    }
}

$ go run main.go

# 輸出如下
mock init ...

package sync

import (
    "sync/atomic"
)

// Once 是一個只執(zhí)行一次操作的對象
// Once 一旦使用后，便不能再復(fù)制
//
// 在 Go 內(nèi)存模型術(shù)語中，once.Do(f) 中函數(shù) f 的返回值會在 once.Do() 函數(shù)返回前完成同步
type Once struct {
    done uint32
    m    Mutex
}

// 當且僅當?shù)谝淮握{(diào)用實例 Once 的 Do 方法時，Do 去調(diào)用函數(shù) f
// 換句話說，調(diào)用 once.Do(f) 多次時，只有第一次調(diào)用會調(diào)用函數(shù) f，即使 f 函數(shù)在每次調(diào)用中有不同的參數(shù)值

// 并發(fā)調(diào)用 Do 函數(shù)時，需要等到其中的一個函數(shù) f 執(zhí)行之后才會返回
// 所以函數(shù) f 中不能調(diào)用同一個 once 實例的 Do 函數(shù) (遞歸調(diào)用)，否則會發(fā)生死鎖
// 如果函數(shù) f 內(nèi)部 panic, Do 函數(shù)同樣認為其已經(jīng)返回，將來再次調(diào)用 Do 函數(shù)時，將不再執(zhí)行函數(shù) f
// 所以這就要求我們寫出健壯的 f 函數(shù)
func (o *Once) Do(f func()) {
    // 下面是一個錯誤的實現(xiàn)
    // if atomic.CompareAndSwapUint32(&o.done, 0, 1) {
    //   f()
    // } 
    
    // 錯誤原因分析: 
    // 這里以數(shù)據(jù)庫連接場景為例，在并發(fā)調(diào)用情況下，假設(shè)其中 1 個 goroutine 正在執(zhí)行函數(shù) f (初始化連接)，
    // 此時其他的 goroutine 將不會等待這個 goroutine 執(zhí)行完成，而是會直接返回，
    // 如果連接發(fā)生了一些延遲，導(dǎo)致函數(shù) f 還未執(zhí)行完成，那么此時連接其實還未建立，
    // 但是其他的 goroutine 認為函數(shù) f 已經(jīng)執(zhí)行完成，連接已建立，可以開始使用了
    // 最后當其他 goroutine 使用未建立的連接操作時，產(chǎn)生報錯

    // 要解決上面的問題， 就需要確保當前函數(shù)返回時， 函數(shù) f 已經(jīng)執(zhí)行完成，
    // 這就是 slow path 退回到互斥鎖的原因，以及為什么 atomic.StoreUint32 需要延遲到函數(shù) f 返回之后
    if atomic.LoadUint32(&o.done) == 0 {
        o.doSlow(f) // slow-path 允許內(nèi)聯(lián)
    }
}

func (o *Once) doSlow(f func()) {
    // 并發(fā)場景下，可能會有多個 goroutine 執(zhí)行到這里
    o.m.Lock()  // 但是只有 1 個 goroutine 能獲取到互斥鎖
    defer o.m.Unlock()
    
    // 注意下面臨界區(qū)內(nèi)的判斷和修改
    
    // 在 atomic.LoadUint32 時為 0 ，不等于獲取到鎖之后也是 0，所以需要二次檢測
    // 因為已經(jīng)獲取到互斥鎖，根據(jù) Go 的同步原語約束，對于字段 done 的修改需要在獲取到互斥鎖之前同步
    // 所以這里直接訪問字段即可，不需要調(diào)用 atomic.LoadUint32 方法
    // 如果有其他 goroutine 已經(jīng)修改了字段 done，那么就不會進入條件分支，沒有任何影響 
    if o.done == 0 {
        // 只要函數(shù) f 成功執(zhí)行過一次，就將 o.done 修改為 1
        // 這樣其他 goroutine 就不會再執(zhí)行了，從而保證了函數(shù) f() 只會執(zhí)行一次，
        // 這里必須使用 atomic.StoreUint32 方法來滿足 Go 的同步原語約束
        defer atomic.StoreUint32(&o.done, 1)
        f()
    }
}