泛型版 Singleflight:Go 中如何防止缓存击穿?

存储 存储软件
article, err, shared := g.Do(strconv.Itoa(id), func() (*Article, error) { return findArticleFromDB(id), nil })

[[443122]]

大家好,我是 polarisxu。

并发是 Go 的优势,但并发也需要很好的进行控制。标准库中有 sync 包,经常使用的功能有 sync.Mutex、sync.WaitGroup 等。其实,除了标准库,还有一个官方的扩展库,也叫 sync,其中有一个子包:sync/singleflight,专门做并发控制,比如防止缓存击穿。

01 从例子说起

看一个模拟缓存的例子,有如下代码:

package main 
 
import ( 
 "errors" 
 "flag" 
 "log" 
 "sync" 

 
var errorNotExist = errors.New("not exist"
 
var n int 
 
func init() { 
 flag.IntVar(&n, "n", 5, "模拟的并发数,默认 5"

 
func main() { 
 flag.Parse() 
 
 var wg sync.WaitGroup 
 wg.Add(n) 
 
 // 模拟并发访问 
 for i := 0; i < n; i++ { 
  go func() { 
   defer wg.Done() 
   // 假设都获取 id = 1 这篇文章 
   article := fetchArticle(1) 
   log.Println(article) 
  }() 
 } 
 wg.Wait() 

 
type Article struct { 
 ID      int 
 Content string 

 
 
func fetchArticle(id int) *Article { 
 article := findArticleFromCache(id) 
 
 if article != nil && article.ID > 0 { 
  return article 
 } 
 
 return findArticleFromDB(id) 

 
var ( 
 cache   = make(map[int]*Article) 
 rwmutex sync.RWMutex 

 
// 模拟从缓存获取数据 
func findArticleFromCache(id int) *Article { 
 rwmutex.RLock() 
 defer rwmutex.RUnlock() 
 return cache[id] 

 
// 模拟从数据库中获取数据 
func findArticleFromDB(id int) *Article { 
 log.Printf("SELECT * FROM article WHERE id=%d", id) 
 article := &Article{ID: id, Content: "polarisxu"
 rwmutex.Lock() 
 defer rwmutex.Unlock() 
 cache[id] = article 
 return article 

  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.
  • 45.
  • 46.
  • 47.
  • 48.
  • 49.
  • 50.
  • 51.
  • 52.
  • 53.
  • 54.
  • 55.
  • 56.
  • 57.
  • 58.
  • 59.
  • 60.
  • 61.
  • 62.
  • 63.
  • 64.
  • 65.
  • 66.
  • 67.
  • 68.
  • 69.
  • 70.
  • 71.
  • 72.

我们模拟 5 个用户并发访问,同时获取 ID=1 的文章,因为缓存中不存在,因此都到后端 DB 获取具体数据。从运行结果可以看出这一点:

$ go run main.go 
2021/12/30 10:32:36 SELECT * FROM article WHERE id=1 
2021/12/30 10:32:36 SELECT * FROM article WHERE id=1 
2021/12/30 10:32:36 &{1 polarisxu} 
2021/12/30 10:32:36 &{1 polarisxu} 
2021/12/30 10:32:36 SELECT * FROM article WHERE id=1 
2021/12/30 10:32:36 &{1 polarisxu} 
2021/12/30 10:32:36 SELECT * FROM article WHERE id=1 
2021/12/30 10:32:36 &{1 polarisxu} 
2021/12/30 10:32:36 SELECT * FROM article WHERE id=1 
2021/12/30 10:32:36 &{1 polarisxu} 
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.

显然这是我们不希望看到的。

02 使用 singleflight

官方的扩展包 golang.org/x/sync 下面有一个子包 singleflight:

Package singleflight provides a duplicate function call suppression mechanism. 
  • 1.

它用来抑制函数的重复调用,这正好符合上面的场景:希望从数据库获取数据的函数只调用一次。

将 fetchArticle 函数改成这样:

var g singleflight.Group 
 
func fetchArticle(id int) *Article { 
 article := findArticleFromCache(id) 
 
 if article != nil && article.ID > 0 { 
  return article 
 } 
 
 v, err, shared := g.Do(strconv.Itoa(id), func() (interface{}, error) { 
  return findArticleFromDB(id), nil 
 }) 
 
  // 打印 shared,看看都什么值 
 fmt.Println("shared===", shared) 
 
 if err != nil { 
  log.Println("singleflight do error:", err) 
  return nil 
 } 
 
 return v.(*Article) 

  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.

singleflight.Group 是一个结构体类型,没有导出任何字段,它代表一类工作并形成一个命名空间,在该命名空间中可以抑制工作单元的重复执行。

该类型有三个方法,它们的功能见注释:

// 执行并返回给定函数的结果,确保对于给定的键,fn 函数只会执行一次。 
// 如果有重复的进来,重复的调用者会等待最原始的调用完成并收到相同的结果。 
// 返回值 shared 指示是否将 v 提供给多个调用者。 
// 返回值 v 是 fn 的执行结果 
// 返回值 err 是 fn 返回的 err 
func (g *Group) Do(key string, fn func() (interface{}, error)) (v interface{}, err error, shared bool) 
// 和 Do 类似,但返回一个 channel(只能接收),用来接收结果。Result 是一个结构体,有三个字段,即 Do 返回的那三个。 
func (g *Group) DoChan(key string, fn func() (interface{}, error)) <-chan Result 
func (g *Group) Forget(key string) 
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.

因此,改后的代码,通过 Group.Do,即使并发多次调用,findArticleFromDB 也只会执行一次,并且这一次的结果会被并发多次执行共享。

运行后,结果如下:

$ go run main.go 
2021/12/30 11:55:44 SELECT * FROM article WHERE id=1 
shared=== true 
2021/12/30 11:55:44 &{1 polarisxu} 
shared=== true 
2021/12/30 11:55:44 &{1 polarisxu} 
shared=== true 
2021/12/30 11:55:44 &{1 polarisxu} 
shared=== true 
2021/12/30 11:55:44 &{1 polarisxu} 
shared=== true 
2021/12/30 11:55:44 &{1 polarisxu} 
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.

和预期一样,findArticleFromDB 只执行了一次,shared 的值也表示结果被多个调用者共享。

所以,使用 Go 后,再也不需要通过类似 Redis 中的 SETNX 这样的命令来实现类似的功能了。

03 Forget 的用途

上面 Group 的方法中,有一个没有给任何注释,即 Forget。从名字猜到,用来忘掉什么,那具体什么意思呢?

通过上面的例子,我们知晓,通过 Do,可以实现多个并发调用只执行回调函数一次,并共享相同的结果。而 Forget 的作用是:

Forget tells the singleflight to forget about a key. Future calls to Do for this key will call the function rather than waiting for an earlier call to complete.

即告诉 singleflight 忘记一个 key,未来对此 key 的 Do 调用将调用 fn 回调函数,而不是等待更早的调用完成,即相当于废弃 Do 原本的作用。

可以在上面例子中 Do 调用之前,调用 g.Forget,验证是否 Do 的调用都执行 fn 函数即 findArticleFromDB 函数了。

04 泛型版本

细心的读者可能会发现,Do 方法返回的 v 是 interface{},在 fetchArticle 函数最后,我们做了类型断言:v.(*Article)。

既然 Go1.18 马上要来了,有了泛型,可以有泛型版本的 singleflight,不需要做类型断言了。GitHub 已经有人实现并开源:https://github.com/marwan-at-work/singleflight。

改成这个泛型版本,要改以下几处:

  • 导入包 marwan.io/singleflight,而非 github.com/marwan-at-work/singleflight,同时移除 golang.org/x/sync/singleflight
  • g 的声明改为:var g singleflight.Group[*Article]
  • Do 的调用,返回值由 interface{} 类型改为:*Article:
article, err, shared := g.Do(strconv.Itoa(id), func() (*Article, error) { 
  return findArticleFromDB(id), nil 
}) 
  • 1.
  • 2.
  • 3.
  • 最后返回时,直接返回 article,不需要做类型断言

05 总结

singleflight 很常用,你在 pkg.go.dev 搜索 singleflight,发现有很多轮子:https://pkg.go.dev/search?q=singleflight,好些项目不是使用官方的 golang.org/x/sync/singleflight,而是自己实现一个,不过这些实现基本只实现了最常用的 Do 方法。感兴趣的可以查看他们的实现。

 

下次项目中需要类似功能,记得使用 singleflight 哦!

 

责任编辑:武晓燕 来源: polarisxu
相关推荐

2021-09-29 18:17:30

Go泛型语言

2021-07-15 07:23:28

Singlefligh设计

2023-11-29 08:19:45

Go泛型缺陷

2023-09-12 11:10:00

代码优化Go

2024-10-15 10:00:06

2021-08-09 10:36:20

GoSlices Maps

2024-10-28 00:40:49

Go语法版本

2022-04-28 12:00:34

Go泛型版排序

2021-12-15 12:59:56

Go泛型版Beta1

2021-11-27 22:20:13

SlicesGo泛型

2022-03-28 13:34:26

Go泛型部署泛型

2023-11-03 14:02:04

Go切片泛型库

2022-04-24 15:29:17

微服务go

2021-10-29 10:55:07

Go 泛型语言

2023-03-10 13:33:00

缓存穿透缓存击穿缓存雪崩

2019-10-12 14:19:05

Redis数据库缓存

2021-12-15 10:23:56

Go 1.18 Bet语言泛型

2021-12-05 23:45:23

Go泛型Maps

2022-04-15 09:55:59

Go 泛型Go 程序函数

2019-11-05 14:24:31

缓存雪崩框架
点赞
收藏

51CTO技术栈公众号