Singleflight 详解在 Go 语言生态中，singleflight 包是专为特定并发场景设计的实用工具，尽管它不属于标准库的一部分，但由 Go 团队维护并广受开发者青睐。
1. Singleflight 的核心价值
singleflight 的核心作用在于确保对同一数据（或称为“键”）的并发请求中，仅有一个 goroutine 实际执行获取数据的操作，例如从数据库中检索。若其他 goroutine 发起相同数据的请求且已有操作正在进行，它们将优雅地等待结果，而非重复执行。首个请求完成后，所有等待的 goroutine 将共享同一结果，极大地提升了效率。
2. 实战演示
以下代码示例展示了 singleflight 的工作原理：
var callCount atomic.Int32 var wg sync.WaitGroup // 模拟从数据库获取数据的函数 func fetchData() (interface{}, error) { callCount.Add(1) time.Sleep(100 * time.Millisecond) return rand.Intn(100), nil } // 使用 singleflight 包装 fetchData 函数 func fetchDataWrapper(g *singleflight.Group, id int) error { defer wg.Done() time.Sleep(time.Duration(id) * 40 * time.Millisecond) v, err, shared := g.Do("key-fetch-data", fetchData) if err != nil { return err } fmt.Printf("Goroutine %d: result: %v, shared: %v\n", id, v, shared) return nil } func main() { var g singleflight.Group // 启动 5 个 goroutine 并行获取数据 const numGoroutines = 5 wg.Add(numGoroutines) for i := 0; i < numGoroutines; i++ { go fetchDataWrapper(&g, i) } wg.Wait() fmt.Printf("Function was called %d times\n", callCount.Load()) }在此示例中，5 个 goroutine 几乎同时尝试获取相同数据。借助 singleflight.Group，仅首个 goroutine 实际执行 fetchData()，其余 goroutine 则等待结果。尽管有 5 个请求，但 fetchData 仅被调用两次，显著提升了效率。shared 标志确认结果是否在多个 goroutine 间复用。
3. Singleflight 的操作详解
创建 Group 对象：这是跟踪与特定键相关的正在进行调用的核心结构。group.Do(key, func)：执行函数并抑制重复请求。传入键和函数，若键无其他正在进行的执行，则运行函数；否则，调用将阻塞直至首个执行完成并返回相同结果。group.DoChan(key, func)：与 group.Do 类似，但提供通道（<-chan Result）而非阻塞。适合异步处理结果或在多个通道上进行选择。group.Forget(key)：从内部映射中删除键，允许以新请求重新执行函数，而非等待上次执行完成。g.DoChan() 的使用示例如下：
// 使用 DoChan 包装 fetchData 函数 func fetchDataWrapper(g *singleflight.Group, id int) error { defer wg.Done() ch := g.DoChan("key-fetch-data", fetchData) res := <-ch if res.Err != nil { return res.Err } fmt.Printf("Goroutine %d: result: %v, shared: %v\n", id, res.Val, res.Shared) return nil }相较于 Do()，DoChan() 允许在不阻塞 goroutine 的情况下执行其他操作，如处理超时或取消：
func fetchDataWrapperWithTimeout(g *singleflight.Group, id int) error { defer wg.Done() ch := g.DoChan("key-fetch-data", fetchData) select { case res := <-ch: if res.Err != nil { return res.Err } fmt.Printf("Goroutine %d: result: %v, shared: %v\n", id, res.Val, res.Shared) case <-time.After(50 * time.Millisecond): return fmt.Errorf("timeout waiting for result") } return nil }此示例揭示了一些实际场景中可能遇到的问题：
首个 goroutine 可能因网络延迟或数据库响应慢而耗时较长，导致其他 goroutine 长时间等待。超时机制可提供帮助，但新请求仍需在首个请求后等待。数据频繁变化时，首个请求的结果可能已过时。此时，需使键无效并触发新执行。group.Forget(key) 可解决此问题。使用 Forget() 的示例：
func fetchDataWrapperWithForget(g *singleflight.Group, id int, forget bool) error { defer wg.Done() if forget { g.Forget("key-fetch-data") } v, err, shared := g.Do("key-fetch-data", fetchData) if err != nil { return err } fmt.Printf("Goroutine %d: result: %v, shared: %v\n", id, v, shared) return nil } func main() { var g singleflight.Group wg.Add(3) go fetchDataWrapperWithForget(&g, 0, false) go fetchDataWrapperWithForget(&g, 1, false) time.Sleep(10 * time.Millisecond) go fetchDataWrapperWithForget(&g, 2, true) wg.Wait() fmt.Printf("Function was called %d times\n", callCount.Load()) }在此示例中，Goroutine 0 和 1 的请求合并为单个执行，结果共享。Goroutine 2 在 Do() 前调用 Forget()，触发了新执行。
总之，尽管 singleflight 功能强大，但仍需注意其边缘情况。首个 goroutine 长时间阻塞时，使用超时上下文或带超时的 select 语句是更优选择。若首个请求出错或引发 panic，错误将传播至所有等待结果的 goroutine。
Singleflight 的工作机制解析通过运用 singleflight 模式，您或许已对其核心运作原理有了初步了解。singleflight 的整个实现精简至约 150 行代码，却能够高效地管理并发请求的去重与执行，展现出卓越的性能和简洁性。
其核心机制围绕每个唯一键构建了一个精细的管理结构，以精准地协调其执行流程。当某个 goroutine 调用 Do() 方法时，如果该键已存在，该调用将会被阻塞，直至首次执行完成。这一机制的关键数据结构如下：
type Group struct { mu sync.Mutex // 保护内部映射 m 的并发访问，确保线程安全 m map[string]*call // 键值映射，用于跟踪调用状态，实现延迟初始化 } type call struct { wg sync.WaitGroup // 等待组，用于同步任务完成，确保结果一致性 val interface{} // 任务执行结果，存储返回值 err error // 任务执行错误，记录异常信息 dups int // 重复请求计数，统计重复调用次数 chans []chan<- Result // 结果接收通道列表，用于异步通知结果 }在这一设计中，两个同步原语发挥着举足轻重的作用：
组互斥锁（g.mu）：此锁如一位忠诚的守卫，保护着整个键映射的并发访问，确保在添加、删除键时的线程安全性。它避免了为每个键单独设锁带来的复杂性，以全局锁的形式简化了并发控制。WaitGroup（g.call.wg）：它如同一位协调者，用于等待与特定键关联的任务完成。通过它，我们能够确保所有等待的 goroutine 在任务完成后都能及时获取到结果。接下来，我们重点解析 group.Do() 方法。由于 group.DoChan() 方法的机制与 group.Do() 类似，而 group.Forget() 方法则相对简单，仅涉及从映射中移除键的操作，因此在此不做赘述。
当调用 group.Do() 时，首先会锁定整个键映射（g.mu）。尽管全局锁在某些场景下可能并非最优选择（建议在实际应用中进行基准测试以评估性能），但考虑到 singleflight 需要锁定整个键集以确保一致性，这种设计在大多数情况下是可行的。对于高性能需求或大规模应用，可以考虑采用分片或分布式处理策略，将负载分散至多个 singleflight 组，从而实现“多飞行”机制。相关实现可参考 shardedsingleflight 仓库。
在获得锁后，会检查内部映射（g.m），判断给定键是否已有进行中或已完成的调用。映射跟踪了所有进行中或已完成的任务，将键映射至对应的任务对象。
若键已存在（即有其他 goroutine 正在执行任务），则不会启动新调用，而是增加计数器（c.dups）以跟踪重复请求的数量，并释放锁。随后，通过 call.wg.Wait() 在 WaitGroup 上等待原始任务完成。原始任务完成后，当前 goroutine 即可获取结果，从而避免重复执行。
以下是 group.Do() 方法的核心代码实现：
func (g *Group) Do(key string, fn func() (interface{}, error)) (v interface{}, err error, shared bool) { g.mu.Lock() if g.m == nil { g.m = make(map[string]*call) } // 键已存在，处理重复请求 if c, ok := g.m[key]; ok { c.dups++ g.mu.Unlock() c.wg.Wait() // 处理特定错误情况 if e, ok := c.err.(*panicError); ok { panic(e) } else if c.err == errGoexit { runtime.Goexit() } return c.val, c.err, true } // 创建新调用并添加到映射中 c := new(call) c.wg.Add(1) g.m[key] = c g.mu.Unlock() // 执行函数 g.doCall(c, key, fn) return c.val, c.err, c.dups > 0 }若键不存在，则当前 goroutine 负责执行任务。它会创建一个新的 call 对象，将其添加到映射中，并初始化 WaitGroup。随后，解锁互斥锁，并通过辅助方法 g.doCall(c, key, fn) 执行任务。任务完成后，等待的 goroutine 会通过 wg.Wait() 解除阻塞，从而获取结果。
在错误处理机制方面，singleflight 考虑了三种情况：
panic 捕获：将 panic 包装为 panicError 并重新引发，以确保开发者代码中的异常处理逻辑能够正确捕获并处理。runtime.Goexit() 调用：直接调用 runtime.Goexit() 以正确退出 goroutine。这会导致当前 goroutine 停止执行，但不会影响其他 goroutine 的运行。普通错误：将错误设置于调用对象上，以便后续处理。g.doCall() 方法处理逻辑更为复杂，特别是错误与 runtime.Goexit() 的检测。它通过精细的控制流和错误处理逻辑，确保了任务的正确执行和结果的准确传递。
在处理 runtime.Goexit() 调用时，关键在于其后代码不会被执行。通过延迟函数检查标志变量，可以检测到 runtime.Goexit() 的调用，从而采取相应的处理措施。
而在处理 panic 时，singleflight 使用了 recover() 进行捕获。但与传统 recover() 使用方式不同，singleflight 在 recover() 块外设置了标志变量，以区分正常返回与 panic 恢复。这一设计使得错误处理更加灵活和准确。
任务完成后，根据错误类型执行相应操作。对于 panic 和 runtime.Goexit()，分别进行捕获和重新引发或正常退出处理；对于正常返回的结果，则通过通道发送至等待的 goroutine。
综上所述，singleflight 机制以其高效、简洁的设计思想，成功实现了并发请求的去重与执行管理。尽管涉及全局锁的使用，但通过精心设计的错误处理与同步机制，确保了在高并发场景下的稳定性和可靠性。这使得 singleflight 成为处理并发请求去重问题的优选方案之一。
