[[443122]]kaiyun官方网站

民众好，我是 polarisxu。

并发是 Go 的上风，但并发也需要很好的进行截止。圭臬库中有 sync 包，时时使用的功能有 sync.Mutex、sync.WaitGroup 等。其实，除了圭臬库，还有一个官方的彭胀库，也叫 sync，其中有一个子包：sync/singleflight，独特作念并发截止，比如堤防缓存击穿。

01 从例子提及

看一个模拟缓存的例子，有如下代码：

package kaiyun官方网站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 } 

咱们模拟 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} 

昭彰这是咱们不但愿看到的。

02 使用 singleflight

官方的彭胀包 golang.org/x/sync 底下有一个子包 singleflight：

Package singleflight provides a duplicate function call suppression mechanism. 

它用来扼制函数的重叠调用，这正巧妥贴上头的场景：但愿从数据库取得数据的函数只调用一次。

将 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) } 

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) 

因此，改后的代码，通过 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} 

和预期同样，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 }) 

临了复返时，平直复返 article，不需要作念类型断言 05 回来

singleflight 很常用，你在 pkg.go.dev 搜索 singleflight，发现存好多轮子：https://pkg.go.dev/search?q=singleflight，好些表情不是使用官方的 golang.org/x/sync/singleflight，而是我方已矣一个，不外这些已矣基本只已矣了最常用的 Do 模范。感兴味的不错稽察他们的已矣。

 

下次表情中需要访佛功能，牢记使用 singleflight 哦!