Go · sync 包与内存模型

func (s S) Inc() { s.mu.Lock(); s.n++; s.mu.Unlock() }   // 错: 值接收者=每次拷贝新锁
// go vet: "Inc passes lock by value: sync.Mutex"
func (s *S) Inc() { s.mu.Lock(); s.n++; s.mu.Unlock() }  // 对: 指针接收者

go func() { wg.Add(1); defer wg.Done(); t() }()  // 错: Wait 可能抢先
wg.Add(1)                          // 对: Add 在 go 语句之前
go func(t Task) { defer wg.Done(); t() }(t)

func read() { mu.RLock(); defer mu.RUnlock(); helper() }
func helper() { mu.RLock(); defer mu.RUnlock() }    // 错: 重入=死锁
// 对: 拆小临界区, helper 不拿锁 (提供内部版/外部版两个入口)

var m sync.Map
for i := 0; i < 1e6; i++ { m.Store(key(i), i) }  // 错: 高频写反而慢
var mu sync.RWMutex; m2 := map[K]V{}          // 对: 甜区外老实上锁
mu.Lock(); m2[k] = v; mu.Unlock()

if !started.Load() {          // 错: 检查与动作之间仍是窗口
    start()                   //   两个 G 都可能通过检查
    started.Store(true)
}
if started.CompareAndSwap(false, true) {  // 对: 原子决策
    start()                   // → 恰好一个 G 执行
}

# 错: -race 全绿就宣布并发安全
# 对: 必要不充分 — 补并发 review + 压测覆盖
go test -race -count=100 ./...   # 多轮放大触发概率
# 预发环境混流再挂 -race (非生产层)

for _, v := range items {
    go func() { use(v) }()    // 错(1.21-): 并发读到错值
    v := v                      // 对: 显式遮蔽 (或升 1.22+)
    go func() { use(v) }()
}

mu.Lock(); callback(event); mu.Unlock()   // 错: 持锁调外部函数
mu.Lock(); ev := *event; mu.Unlock()      // 对: 先拷贝数据
callback(ev)                             //    回调移出临界区

mu.Lock(); defer mu.Unlock()   // 错: 中间 IO 全程持锁
resp, err := callRemote()
mu.Lock(); v := cache[k]; mu.Unlock()   // 对: 只锁取数据一小段
resp, err = callRemote(v)

type M struct{ min, max atomic.Int64 }   // 错: 各自原子≠整体一致
m.min.Store(2); m.max.Store(9)           //   读者见新 min 旧 max
type M struct{ mu sync.Mutex; min, max int64 }  // 对: 锁保复合不变量

var wg sync.WaitGroup              // 错: 跨轮共用, Wait/Add 交错
for round := 0; round < n; round++ {
    wg := sync.WaitGroup{}       // 对: 每轮新建
    for _, t := range tasks { wg.Add(1); go work(&wg, t) }
    wg.Wait()
}

once.Do(func() { mustInit() })  // 错: panic 后视同"已执行"
// 之后 Do 直接返回 → 永久坏状态, 不再重试
// 对: f 内 recover 并暴露重试入口
once.Do(func() { if r := recover(); r != nil { allowRetry() } })

go func() { for k := range m { _ = k } }()
m[k] = v                          // 错: → fatal error:
                                  //   concurrent map iteration and map write
// 对: 迭代中收集变更, 循环外统一应用 (或 sync.Map)

var s []int
go func() { s = append(s, 1) }()   // 错: 互相覆盖丢数据
go func() { s = append(s, 2) }()
s := make([]int, n)                  // 对: 预分配各写各下标
for i := 0; i < n; i++ { go func(i int) { s[i] = work(i) }(i) }

buf := make([]byte, 0, 4096)          // G 私有
mu.Lock(); buf = append(buf, b...); mu.Unlock()  // 错: 纯开销
buf = append(buf, b...)                    // 对: 所有权明确无需锁
out <- buf                                 //    交接点才需要(chan 自带)

pool.Put(userSession)               // 错: 当缓存期待命中
v, _ := pool.Get().(*Session)      // GC 一到池可能清空
// 对: Pool 只降分配率 (Get/Hit 率进指标)
//     数据缓存用带 TTL 结构 (ristretto/bigcache)

x.Store(x.Load() + 1)           // 错: 两步之间已被别的 G 改
x.Add(1)                          // 对: 原子加
for {                             //    复杂逻辑用 CAS 循环
    o := x.Load()
    if x.CompareAndSwap(o, o*2) { break }
}

ctx = context.WithValue(ctx, "order", order)  // 错: 业务参数塞 ctx
process(ctx, order)                             // 对: 显式传参
ctx = context.WithValue(ctx, traceIDKey, tid)   // ctx 只带元数据

// 错: 以为死锁必然触发 "all goroutines are asleep"
//     部分死锁(还有 worker 在跑)永远不报
select {                          // 对: 超时兜底
case ch <- v:
case <-time.After(3 * time.Second):
    return ErrStuck              // + pprof goroutine 巡检
}

# 错: 本地 -race 全绿就不管了
# 对: -race 进 CI 必跑 + 预发长时间混流
go test -race ./...
GOFLAGS=-race ./app --canary    # 预发金丝雀(非生产层, 接受慢)