Go并发利器：singleflight如何防止缓存击穿

技术圈

发布于 2026-04-13 11:57:07

在高并发场景下，你是否遇到过这样的困扰：当缓存失效的瞬间，大量请求同时涌入数据库，导致数据库压力骤增甚至崩溃？这就是典型的缓存击穿问题。这篇文章来介绍Go语言官方扩展库中的一个利器——singleflight，它能优雅地解决这个问题。

singleflight的核心原理

singleflight的核心思想非常简单：当多个goroutine同时请求同一个资源时，它确保只有一个goroutine真正执行请求，其他goroutine等待并共享这个结果。

想象一下，如果多个人同时想点外卖，与其每个人都打开外卖APP下单，不如大家凑在一起，由一个人下单，然后大家共享这份外卖。这就是singleflight的工作方式。

从技术角度看，singleflight内部维护了一个map，key是请求的标识，value是正在执行的请求。当一个新的请求到来时，它会先检查map中是否已经有相同的请求正在执行：

如果有，就直接等待那个请求的结果
如果没有，就创建一个新的请求并执行

这样，无论有多少个并发请求，最终只有一次实际操作被执行。

请求合并示例

让我们通过一个简单的例子来看看singleflight如何实现请求合并：

func main() {
    g := new(singleflight.Group)
    
    // 第1次调用
    gofunc() {
        v1, _, _ := g.Do("key", func() (interface{}, error) {
            fmt.Println("执行查询...")  // 只会打印一次
            time.Sleep(2 * time.Second)
            return"result", nil
        })
        fmt.Printf("1st: %v\n", v1)
    }()
    
    time.Sleep(100 * time.Millisecond)
    
    // 第2次调用（等待第1次的结果）
    v2, _, _ := g.Do("key", func() (interface{}, error) {
        fmt.Println("执行查询...")  // 不会执行
        return"result", nil
    })
    fmt.Printf("2nd: %v\n", v2)
}

输出结果：

执行查询...
1st: result
2nd: result

注意看输出结果："执行查询..."只打印了一次，说明函数只被执行了一次。这就是singleflight的魔力：多个并发请求被合并成一个，既减少了资源消耗，又提高了系统效率。

什么是缓存击穿

了解了singleflight的基本用法后，我们再来看看它最典型的应用场景——防止缓存击穿。

当某个热点数据的缓存过期时，如果有大量并发请求同时访问这个数据，这些请求会发现缓存为空，于是都会去查询数据库。这就好比商场的特价活动，原本大家有序排队，突然门开了，所有人同时涌入，场面瞬间失控。

传统的解决方案通常有两种：

一是使用互斥锁，只允许一个请求查询数据库，其他请求等待。但这种方式会导致所有请求串行执行，性能较差。

二是预先设置热点数据永不过期，但这需要人工介入，维护成本高。

而singleflight提供了第三种方案：请求合并。它允许多个请求并发等待，但只有一个请求真正执行查询，其他请求共享结果。

实战应用场景

让我们通过一个具体的例子来看看如何使用singleflight防止缓存击穿。假设我们有一个用户信息查询接口，需要从数据库获取数据并缓存：

func GetUser(userID string) (string, error) {
    // 先查缓存，如果存在直接返回
    if val, ok := cache[userID]; ok {
        return val, nil
    }
    
    // 使用singleflight合并请求
    val, err, _ := sg.Do(userID, func() (interface{}, error) {
        data := queryFromDB(userID)  // 查询数据库
        cache[userID] = data         // 写入缓存
        return data, nil
    })
    
    return val.(string), err
}

这段代码的关键在于sg.Do方法。第一个参数是请求的唯一标识，第二个参数是实际要执行的函数。当多个goroutine同时调用GetUser("123")时，只有一个goroutine会真正执行数据库查询，其他goroutine会等待并共享结果。

主要方法详解

singleflight提供了三个主要方法，各有其适用场景。

Do方法是最常用的，它会阻塞等待结果返回。适合大多数同步场景。

DoChan方法返回一个channel，可以配合select使用，实现超时控制：

ch := sg.DoChan(key, func() (interface{}, error) {
    return fetchData(), nil
})

select {
case result := <-ch:
    // 处理结果
case <-time.After(3 * time.Second):
    // 超时处理
}

Forget方法用于使某个key失效，下次请求会重新执行。这在数据更新后需要立即刷新的场景很有用。

性能对比

让我们通过一个简单的性能测试来看看singleflight的效果。

假设有100个并发请求同时查询同一个用户信息：

不使用singleflight时，100个请求会同时查询数据库，数据库瞬间承受100倍压力。

使用singleflight后，100个请求中只有1个会查询数据库，其他99个等待并共享结果，数据库压力降低99%。

这种优化在高并发场景下尤为明显。曾经有一个电商项目，在大促期间因为缓存击穿导致数据库崩溃。引入singleflight后，数据库QPS从峰值10万降低到几百，系统稳定性大幅提升。

注意事项

虽然singleflight很强大，但在使用时也需要注意几个问题。

首先是结果共享机制。所有等待的goroutine会共享同一个结果，这意味着如果结果是指针类型，多个goroutine可能会同时修改它。因此，要么返回值类型，要么确保结果不会被修改。

其次是错误传播。如果执行的函数返回错误，所有等待的goroutine都会收到相同的错误。这在某些场景下可能不是期望的行为，需要结合重试机制使用。

最后是内存泄漏风险。如果执行的函数长时间不返回，会导致大量goroutine阻塞。建议配合context和超时机制使用：

ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

result, err, _ := sg.Do(key, func() (interface{}, error) {
    return fetchDataWithContext(ctx)
})