Go 常见的并发模式有哪些？怎么控制并发数？

lim := rate.NewLimiter(rate.Limit(100), 20) // 每秒补充 100 个令牌，桶容量 20（允许的突发量）
if err := lim.Wait(ctx); err != nil {
	return err
}

// 带取消的 worker pool：生产者和 worker 都监听 ctx，任何一方提前退出都不会让别人永远阻塞
package main

import (
	"context"
	"fmt"
	"sync"
	"time"
)

func workerPool(ctx context.Context, jobs <-chan int, workers int) <-chan int {
	results := make(chan int)
	var wg sync.WaitGroup
	for range workers {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for n := range jobs { // jobs 关闭后退出
				select {
				case results <- n * n:
				case <-ctx.Done():
					return // 消费方不再接收，及时退出
				}
			}
		}()
	}
	go func() {
		wg.Wait()
		close(results) // 所有 worker 都退出后关闭，消费方的 range 才能结束
	}()
	return results
}

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()
	jobs := make(chan int)
	go func() {
		defer close(jobs) // 唯一的发送方负责关闭
		for i := 1; i <= 10; i++ {
			select {
			case jobs <- i:
			case <-ctx.Done():
				return
			}
		}
	}()
	sum := 0
	for r := range workerPool(ctx, jobs, 3) {
		sum += r
	}
	fmt.Println("sum:", sum) // sum: 385
}

// 用 singleflight 包装缓存未命中后的查库，queryDB 是实际查数据库的函数
var group singleflight.Group // 来自 golang.org/x/sync/singleflight，零值可用

func getUser(ctx context.Context, id string) (string, error) {
	// 同一个 key 同一时刻只有一个调用真正执行 queryDB，其余调用方等待并共享结果
	v, err, _ := group.Do("user:"+id, func() (any, error) {
		return queryDB(ctx, id)
	})
	if err != nil {
		return "", err
	}
	return v.(string), nil
}