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

package main

import (

    "log"

    "net/http"

    "sync"

)

type Config struct {

    APIKey   string

    LogLevel string

}

var (

    config *Config

    once   sync.Once

)

func loadConfig() {

    // 模拟从文件或环境变量加载配置

    config = &Config{

       APIKey:   "secret-key",

       LogLevel: "debug",

    }

    log.Println("Configuration loaded")

}

func GetConfig() *Config {

    once.Do(loadConfig) // 仅第一次访问时会执行loadConfig函数

    return config

}

func handler(w http.ResponseWriter, r *http.Request) {

    cfg := GetConfig()

    log.Printf("Request handled with API key: %s", cfg.APIKey)

    w.Write([]byte("OK"))

}

func main() {

    http.HandleFunc("/", handler)

    log.Fatal(http.ListenAndServe(":8888", nil))

}

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

package sync

import (

    "sync/atomic"

)

type Once struct {

    done atomic.Uint32 // 是否已执行标识位，0-未执行 1-已执行

    m    Mutex         // 互斥锁，确保并发安全

}

func (o *Once) Do(f func()) {

    // 第一次执行Do函数时，原子操作检查o.done==0,执行doSlow函数后，o.done==1

    // 第二次及之后执行Do函数,原子操作检查o.done标识位为1，Do函数不执行任何功能，确保了f函数只在第一次被执行

    if o.done.Load() == 0 {

       o.doSlow(f) // 调用doSlow函数执行f方法。第一次执行时，同一时间可能有多个goroutine尝试同时执行doSlow函数

    }

}

func (o *Once) doSlow(f func()) {

    o.m.Lock() // 加锁保护，避免多个goroutine同时绕过之前的原子操作检查，并发修改o.done的值

    defer o.m.Unlock()

    // 二次检查o.done的值，同一时间并发执行doSlow函数的goroutine,在第一个goroutine将o.done置为1并解除互斥锁后,

    // 剩下的goroutine识别到自身的o.done已经被设为1，无法绕过二次检查

    if o.done.Load() == 0 {

       defer o.done.Store(1) // 需要在f()函数执行完成之后，原子性地将o.done设为1

       f() // 执行f方法，一定只有一个goroutine会调用这个方法

    }

}