Go的singleflight

// Group 代表一个 singleflight 分组，不同 key 的请求隔离
var g singleflight.Group

// Do：同步调用，key 相同时只执行一次 fn，返回共享结果
val, err, shared := g.Do("key", func() (any, error) {
    return fetchFromDB(), nil
})
// shared 为 true 表示结果被其他调用者共享

// DoChan：异步版本，返回 channel
ch := g.DoChan("key", func() (any, error) {
    return fetchFromDB(), nil
})
result := <-ch

// Forget：删除 key 对应的已缓存结果，下次 Do 会重新执行 fn
g.Forget("key")

var g singleflight.Group

func GetArticle(ctx context.Context, id int64) (*Article, error) {
    // 先查 Redis 缓存
    cacheKey := fmt.Sprintf("article:%d", id)
    val, err := redis.Get(ctx, cacheKey)
    if err == nil {
        return parseArticle(val), nil
    }

    // 缓存未命中，用 singleflight 合并去数据库的请求
    // 同一篇文章 1000 个并发请求只会触发 1 次 DB 查询
    v, err, _ := g.Do(cacheKey, func() (any, error) {
        // 可能第一个请求查了 Redis 也没有，所以这里再次 double-check
        // 也可以省略，取决于是否需要
        article, err := db.QueryArticle(ctx, id)
        if err != nil {
            return nil, err
        }
        // 写入缓存
        redis.Set(ctx, cacheKey, serialize(article), 10*time.Minute)
        return article, nil
    })
    if err != nil {
        return nil, err
    }
    return v.(*Article), nil
}

func GetArticle(ctx context.Context, id int64) (*Article, error) {
    cacheKey := fmt.Sprintf("article:%d", id)
    val, err := redis.Get(ctx, cacheKey)
    if err == nil {
        return parseArticle(val), nil
    }

    lockKey := fmt.Sprintf("lock:article:%d", id)
    lock, err := redis.Lock(ctx, lockKey, 5*time.Second)
    if err != nil {
        time.Sleep(50 * time.Millisecond)
        return GetArticle(ctx, id) // 重试读缓存
    }
    defer lock.Unlock()

    // 双检
    if val, err := redis.Get(ctx, cacheKey); err == nil {
        return parseArticle(val), nil
    }
    return db.QueryArticle(ctx, id)
}

// 简化版实现，辅助理解核心逻辑
type call struct {
    wg  sync.WaitGroup // 用于等待 fn 执行完成
    val any
    err error
}

type Group struct {
    mu sync.Mutex
    m  map[string]*call // key → 正在执行的调用
}

func (g *Group) Do(key string, fn func() (any, error)) (any, error, bool) {
    g.mu.Lock()
    if g.m == nil {
        g.m = make(map[string]*call)
    }
    // 已有正在进行中的调用 → 等结果
    if c, ok := g.m[key]; ok {
        g.mu.Unlock()
        c.wg.Wait()
        return c.val, c.err, true // shared = true
    }
    // 第一个调用者 → 新建 call 并执行
    c := new(call)
    c.wg.Add(1)
    g.m[key] = c
    g.mu.Unlock()

    c.val, c.err = fn()
    c.wg.Done()

    // 执行完毕，从 map 中删除，后续新请求可重新执行
    g.mu.Lock()
    delete(g.m, key)
    g.mu.Unlock()

    return c.val, c.err, false
}