文章详情

短信预约-IT技能 免费直播动态提醒

请输入下面的图形验证码

提交验证

短信预约提醒成功

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

2024-12-02 10:49

关注

大家好,我是 polarisxu。

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

01 从例子说起

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

  1. package main 
  2.  
  3. import ( 
  4.  "errors" 
  5.  "flag" 
  6.  "log" 
  7.  "sync" 
  8.  
  9. var errorNotExist = errors.New("not exist"
  10.  
  11. var n int 
  12.  
  13. func init() { 
  14.  flag.IntVar(&n, "n", 5, "模拟的并发数,默认 5"
  15.  
  16. func main() { 
  17.  flag.Parse() 
  18.  
  19.  var wg sync.WaitGroup 
  20.  wg.Add(n) 
  21.  
  22.  // 模拟并发访问 
  23.  for i := 0; i < n; i++ { 
  24.   go func() { 
  25.    defer wg.Done() 
  26.    // 假设都获取 id = 1 这篇文章 
  27.    article := fetchArticle(1) 
  28.    log.Println(article) 
  29.   }() 
  30.  } 
  31.  wg.Wait() 
  32.  
  33. type Article struct { 
  34.  ID      int 
  35.  Content string 
  36.  
  37.  
  38. func fetchArticle(id int) *Article { 
  39.  article := findArticleFromCache(id) 
  40.  
  41.  if article != nil && article.ID > 0 { 
  42.   return article 
  43.  } 
  44.  
  45.  return findArticleFromDB(id) 
  46.  
  47. var ( 
  48.  cache   = make(map[int]*Article) 
  49.  rwmutex sync.RWMutex 
  50.  
  51. // 模拟从缓存获取数据 
  52. func findArticleFromCache(id int) *Article { 
  53.  rwmutex.RLock() 
  54.  defer rwmutex.RUnlock() 
  55.  return cache[id] 
  56.  
  57. // 模拟从数据库中获取数据 
  58. func findArticleFromDB(id int) *Article { 
  59.  log.Printf("SELECT * FROM article WHERE id=%d", id) 
  60.  article := &Article{ID: id, Content: "polarisxu"
  61.  rwmutex.Lock() 
  62.  defer rwmutex.Unlock() 
  63.  cache[id] = article 
  64.  return article 

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

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

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

02 使用 singleflight

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

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

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

将 fetchArticle 函数改成这样:

  1. var g singleflight.Group 
  2.  
  3. func fetchArticle(id int) *Article { 
  4.  article := findArticleFromCache(id) 
  5.  
  6.  if article != nil && article.ID > 0 { 
  7.   return article 
  8.  } 
  9.  
  10.  v, err, shared := g.Do(strconv.Itoa(id), func() (interface{}, error) { 
  11.   return findArticleFromDB(id), nil 
  12.  }) 
  13.  
  14.   // 打印 shared,看看都什么值 
  15.  fmt.Println("shared===", shared) 
  16.  
  17.  if err != nil { 
  18.   log.Println("singleflight do error:", err) 
  19.   return nil 
  20.  } 
  21.  
  22.  return v.(*Article) 

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

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

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

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

运行后,结果如下:

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

和预期一样,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。

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

  1. article, err, shared := g.Do(strconv.Itoa(id), func() (*Article, error) { 
  2.   return findArticleFromDB(id), nil 
  3. }) 

05 总结

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

 

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

 

来源:polarisxu内容投诉

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题
  • 2024年上半年信息系统项目管理师第二批次真题及答案解析(完整版)

    难度     813人已做
    查看
  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看
  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看
  • 2024年上半年软考高项第一、二批次真题考点汇总(完整版)

    难度     435人已做
    查看
  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机
位置:首页-资讯-后端开发
咦!没有更多了?去看看其它编程学习网 内容吧
首页课程
资料下载
问答资讯