Go防缓存击穿——singleflight

我们在开发时，有时会碰到一个接口的访问量突然上升，导致服务响应延迟或者宕机的情况。这时，除了利用缓存之外，也可以用到singlefilght来解决，下面是一个简单的示例

package main

import (
	"fmt"
	"sync"
	"sync/atomic"
	"time"

	"golang.org/x/sync/singleflight"
)

func main() {
	g := singleflight.Group{}

	wg := sync.WaitGroup{}

	for i := 0; i < 100; i++ {
		wg.Add(1)
		go func(j int) {
			defer wg.Done()
			val, err, shared := g.Do("a", a)
			if err != nil {
				fmt.Println(err)
				return
			}
			fmt.Printf("index: %d, val: %d, shared: %v\n", j, val, shared)
		}(i)
	}

	wg.Wait()

}

var (
	count = int64(0)
)

// 模拟接口方法
func a() (interface{}, error) {
	time.Sleep(time.Millisecond * 500)
	return atomic.AddInt64(&count, 1), nil
}

// 部分输出，shared表示是否共享了其他请求的返回结果
index: 2, val: 1, shared: false
index: 71, val: 1, shared: true
index: 69, val: 1, shared: true
index: 73, val: 1, shared: true
index: 8, val: 1, shared: true
index: 24, val: 1, shared: true

val这里绝大部分都为1是因为程序运行时间太快了，可以试着把time.Sleep时间缩短一点看看效果

singleflight核心代码非常简单

// 成员非常少，就两个
type Group struct {
	mu sync.Mutex      
	m  map[string]*call
}

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)
	}
	// 判断key是否存在，存在则表示有其他请求先一步进来，
	// 直接等待其他请求返回就行
	if c, ok := g.m[key]; ok {
		c.dups++
		g.mu.Unlock()
		c.wg.Wait()
		return c.val, c.err, true
	}
	// 不存在就创建一个新的call对象，然后去执行
	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
}

doCall方法很简单，这里就不展开了，除了Do方法之外，还有一个异步的DoChan方法，原理一模一样。

我们一般可以在一些类似于幂等的接口上用singleflight 它源码非常短，有需要的可以去展开阅读，代码思路非常清楚