Go · GMP 协程调度模型

// 错: for _, r := range reqs { go handle(r) }  → 瞬时 10 万 G
sem := make(chan struct{}, 100)     // 对: 在途上限 100
for _, r := range reqs {
    sem <- struct{}{}                 // 满了排队, 不打爆
    go func(r Req) { defer func() { <-sem }(); handle(r) }(r)
}

// 错: ch <- result (无人接收, G 永久卡在 send)
select {                          // 对: 一律带超时/取消
case ch <- result:
case <-ctx.Done():                // → context canceled, G 正常退出
}

# 错: CPU limit=2 但宿主机 64 核 → GOMAXPROCS=64, 被 CFS throttle
# 对: 自动对齐 cgroup 配额
import _ "github.com/uber-go/automaxprocs"  # → GOMAXPROCS=2

for _, v := range items {
    go func() { use(v) }()        // 错(1.21-): 并发下全拿到最后一个 v
    go func(v int) { use(v) }(v)  // 对: 按值传参 (或每轮 v := v)
}

// 错: go do(); time.Sleep(time.Second)  → 时序碰运气
done := make(chan struct{})        // 对: 等"什么"就等"什么"
go func() { do(); close(done) }()
<-done                            // → 精确同步, 零竞态

go func() { panic("boom") }()   // 错: 裸 go, 整个进程被打死
// 对: 统一封装, 入口顶层 recover
func safe(fn func() error) {
    defer func() { if r := recover(); r != nil { log.Error(r) } }()
    fn()
}

for _, f := range files {
    fh, _ := os.Open(f)
    defer fh.Close()               // 错: 万个句柄攒到函数返回才释放
}
for _, f := range files { process(f) }  // 对: defer 进 process 内随轮归还

for _, t := range tasks {
    go func() { wg.Add(1); t() }()   // 错: Wait 抢先返回, 少算
    wg.Add(1)                          // 对: Add 在 go 语句之前
}

ch := make(chan int)       // 错: 无缓冲
ch <- 1; fmt.Println(<-ch)   // → fatal error: all goroutines are asleep
ch2 := make(chan int, 1)   // 对: 有缓冲 (或 send 放进另一个 G)
ch2 <- 1; fmt.Println(<-ch2)  // → 1

for {
    select {
    case <-ctx.Done():              // 对: 第一分支固定写退出
        return
    case job := <-jobs:            // 只有此分支 = 错形态, 永转不停
        run(job)
    }
}

for i := 0; i < 1e9; i++ {
    runtime.Gosched()             // 错(过时): 1.14+ 异步抢占已内置
    work(i)
}
for i := 0; i < 1e9; i++ { work(i) }  // 对: 直接算; 超长任务下沉 worker

// 错: go func() { audit(order) }()  → 日志无 traceId, 排查断链
go func(ctx context.Context, o Order) {  // 对: ctx 作为第一个参数
    log.From(ctx).Info("audit")          // → traceId 自动注入
    audit(ctx, o)
}(ctx, order)

# 错: 无监控, 上线三天 OOM 才发现泄漏
# 对: go_goroutines 告警看斜率, 不看绝对值
deriv(go_goroutines[10m]) > 0.5   # → 持续增长即疑似泄漏

for !done { time.Sleep(100 * time.Millisecond) }  // 错: 竞态+空转
done := make(chan struct{})                // 对: 事件驱动
close(done); <-done                             // → 精确唤醒

func main() {
    go flusher()                    // 错: main 一退 flusher 立即死
    serve()                        // → 尾批数据/未 ack 消息丢失
    wg.Wait(); flush()            // 对: 退出前 Wait + 强制 flush
}

big := make([]byte, 64<<20)     // 64MB
go func() { use(big) }()          // 错: 64MB 被 G 拉满整个生命周期
go func(n int) { calc(n) }(len(big))  // 对: 只带需要的值

defer log.Println("defer 仍执行")   // Goexit 与 panic 一样跑 defer
runtime.Goexit()               // 只终止当前 G, 调用方无感知
// 错: 测试里用 Goexit 跳过断言 → 静默假绿
// 对: 断言失败直接 t.Fatal("bad state")

go func() {                    // 错: 内层新 G 不带 ctx
    go cleanup()                // 外层取消它也不知道, 泄漏转移
}()
go func() { go cleanup(ctx) }()  // 对: 派生一律用传入的 ctx

# 错: 本机 16 核压测 P99=10ms, 直接外推生产
# 对: 与生产同限核同参数再压
GOMAXPROCS=2 ./bench                      # 模拟容器 CPU limit=2
docker run --cpus=2 --memory=4g app        # → 压出真实容量

for _, job := range jobs {
    go handle(job)                  // 错: 无上限无生命周期, 排队靠运气
}
g, ctx := errgroup.WithContext(ctx)          // 对: 限流+取消+等待
g.SetLimit(50)                              // → 上限 50, 可取消, 可等待
for _, job := range jobs { g.Go(func() error { return handle(ctx, job) }) }
g.Wait()