泛型版 Singleflight：Go 中如何防止緩存擊穿？

作者：站長polaris 2021-12-30 18:34:29

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

大家好，我是 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 
}

我們模擬 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 哦!

責任編輯：武曉燕來源： polarisxu

緩存 Go Singleflight