sync/atomic — 原子操作与无锁编程

counter++ // 非原子：读 → 加 → 写 三步，并发下会丢更新

atomic.AddInt64(&counter, 1) // 原子：硬件保证整体不可分割

var counter atomic.Int64
counter.Add(1)          // 返回加后的新值
n := counter.Load()
counter.Store(0)
counter.CompareAndSwap(0, 100)

var flag atomic.Bool
flag.Store(true)
if flag.CompareAndSwap(false, true) { ... } // 抢占式"只让一个做"

var ptr atomic.Pointer[Config] // 泛型指针，类型安全
ptr.Store(&Config{Port: 8080})
cfg := ptr.Load()

var bits atomic.Uint32
old := bits.Or(1 << 3)   // 原子置位
old = bits.And(^(1 << 3)) // 原子清位

var counter int64
atomic.AddInt64(&counter, 1)
val := atomic.LoadInt64(&counter) // 必须用 Load，直接 counter 读不是原子语义保证
atomic.StoreInt64(&counter, 0)
old := atomic.SwapInt64(&counter, 100)

// 语义：若 *addr == old，写入 new 并返回 true；否则不改、返回 false
swapped := counter.CompareAndSwap(old, new)

// "读-改-写"复合更新（比如取最大值）
func updateMax(x *atomic.Int64, v int64) {
    for {
        old := x.Load()
        if v <= old {
            return
        }
        if x.CompareAndSwap(old, v) {
            return
        }
        // 有别人抢先改了，重试
    }
}

var config atomic.Value

config.Store(&Config{Port: 8080})
cfg := config.Load().(*Config)

// Go 1.17+ 增补
config.CompareAndSwap(oldCfg, newCfg)
old := config.Swap(newCfg)

var conf atomic.Pointer[AppConfig]

// 加载/热更新：整份替换，从不就地修改
func reload(path string) error {
    c, err := parse(path)
    if err != nil {
        return err
    }
    conf.Store(c) // 读侧要么旧要么新，绝不会读到半新半旧
    return nil
}

// 读侧
func handler(w http.ResponseWriter, r *http.Request) {
    c := conf.Load() // 一次 Load，整个请求用同一份快照
    render(w, c.Theme)
}

// 错误写法（网上常见的"atomic.Bool 当 Once"）：
var initialized atomic.Bool
func ensureInit() {
    if initialized.Load() {
        return
    }
    doExpensiveSetup()   // ← 两个 goroutine 同时到达会各自执行一遍！
    initialized.Store(true)
}

// 正确写法 1：CAS 抢执行权（注意：后来者会立刻返回，可能还没初始化完！）
var started atomic.Bool
func ensureInit() {
    if started.CompareAndSwap(false, true) {
        doExpensiveSetup()
    }
    // 若需要"必须等它做完"，这里还得再同步（等 Done 标志/条件变量）
}

// 正确写法 2（首选）：sync.OnceValue（Go 1.21+），自带 happens-before 与"等待完成"语义
var getConn = sync.OnceValue(func() *Conn { return dial() })

// 有错误返回的场景
var getConf = sync.OnceValues(func() (*Conf, error) { return load() })

type node struct {
    value int
    next  *node
}

type LockFreeStack struct {
    head atomic.Pointer[node]
}

func (s *LockFreeStack) Push(v int) {
    n := &node{value: v}
    for {
        old := s.head.Load()
        n.next = old
        if s.head.CompareAndSwap(old, n) {
            return
        }
    }
}

func (s *LockFreeStack) Pop() (int, bool) {
    for {
        old := s.head.Load()
        if old == nil {
            return 0, false
        }
        if s.head.CompareAndSwap(old, old.next) {
            return old.value, true
        }
    }
}

// goroutine A
data = 42                    // 普通写
flag.Store(true)             // 原子写

// goroutine B
if flag.Load() {             // 原子读看到 true
    use(data)                // 保证看到 42（Store 先于 Load 同步）
}