Go 并发原语 - atomic

var counter int64

// 多个 goroutine 并发递增
var wg sync.WaitGroup
for i := 0; i < 10000; i++ {
    wg.Add(1)
    go func() {
        defer wg.Done()
        atomic.AddInt64(&counter, 1) // 原子 +1
    }()
}
wg.Wait()
fmt.Println(counter) // 稳定输出 10000

atomic.AddInt64(&counter, -1)  // 原子 -1

// 对于 uint 类型，利用补码：
atomic.AddUint32(&ucount, ^uint32(0))  // 等价于 -1

var flag int32

// goroutine A：原子写
atomic.StoreInt32(&flag, 1)

// goroutine B：原子读
if atomic.LoadInt32(&flag) == 1 {
    fmt.Println("flag 已设置")
}

// CAS: 如果当前值 == old，则设置为 new，返回是否成功
swapped := atomic.CompareAndSwapInt64(&value, old, new)

// 原子地把 value 翻倍
for {
    old := atomic.LoadInt64(&value)
    new := old * 2
    if atomic.CompareAndSwapInt64(&value, old, new) {
        break // CAS 成功，退出
    }
    // CAS 失败（被其他 goroutine 修改了），重试
}

// 旧写法：函数式，需要传指针
var counter int64
atomic.AddInt64(&counter, 1)
v := atomic.LoadInt64(&counter)

// 新写法（Go 1.19+）：方法式，更安全
var counter atomic.Int64
counter.Add(1)
v := counter.Load()

var config atomic.Value

// 初始化
config.Store(map[string]string{
    "host": "localhost",
    "port": "8080",
})

// goroutine A：原子更新配置
config.Store(map[string]string{
    "host": "prod.example.com",
    "port": "443",
})

// goroutine B：原子读取配置
cfg := config.Load().(map[string]string)
fmt.Println(cfg["host"])

type Config struct {
    Host string
    Port int
}

var configPtr atomic.Pointer[Config]

// 原子更新
configPtr.Store(&Config{Host: "localhost", Port: 8080})

// 原子读取
cfg := configPtr.Load()
fmt.Println(cfg.Host) // 无需类型断言

type node[T any] struct {
    value T
    next  *node[T]
}

type LockFreeStack[T any] struct {
    top atomic.Pointer[node[T]]
}

func (s *LockFreeStack[T]) Push(value T) {
    n := &node[T]{value: value}
    for {
        old := s.top.Load()
        n.next = old
        if s.top.CompareAndSwap(old, n) {
            return // CAS 成功
        }
        // CAS 失败，重试
    }
}

func (s *LockFreeStack[T]) Pop() (T, bool) {
    for {
        old := s.top.Load()
        if old == nil {
            var zero T
            return zero, false // 栈为空
        }
        if s.top.CompareAndSwap(old, old.next) {
            return old.value, true // CAS 成功
        }
        // CAS 失败，重试
    }
}

type Bad struct {
    flag bool        // 1 byte
    counter int64    // ❌ 偏移 1 byte，未对齐
}

type Good struct {
    counter int64    // ✅ 放在第一个字段，保证对齐
    flag bool
}

var counter int64

// goroutine A
atomic.AddInt64(&counter, 1) // 原子操作

// goroutine B
fmt.Println(counter) // ❌ 直接读取，非原子！

// ❌ 高竞争下空转
for !atomic.CompareAndSwapInt64(&v, old, new) {
    old = atomic.LoadInt64(&v)
    new = f(old)
}

// ✅ 加入 runtime.Gosched() 让出 CPU
for !atomic.CompareAndSwapInt64(&v, old, new) {
    runtime.Gosched() // 让其他 goroutine 有机会执行
    old = atomic.LoadInt64(&v)
    new = f(old)
}

# 两个应该加入 CI 的命令
go vet ./...
go test -race ./...