使用Golang的singleflight防止缓存击穿的方法

亲爱的编程学习爱好者，如果你点开了这篇文章，说明你对《使用Golang的singleflight防止缓存击穿的方法》很感兴趣。本篇文章就来给大家详细解析一下，主要介绍一下防止缓存击穿，希望所有认真读完的童鞋们，都有实质性的提高。

在使用缓存时，容易发生缓存击穿。

缓存击穿：一个存在的key，在缓存过期的瞬间，同时有大量的请求过来，造成所有请求都去读dB，这些请求都会击穿到DB，造成瞬时DB请求量大、压力骤增。

singleflight

介绍

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

singleflight类的使用方法就新建一个singleflight.Group，使用其方法Do或者DoChan来包装方法，被包装的方法在对于同一个key，只会有一个协程执行，其他协程等待那个协程执行结束后，拿到同样的结果。

Group结构体

代表一类工作，同一个group中，同样的key同时只能被执行一次。

Do方法

func (g *Group) Do(key string, fn func() (interface{}, error)) (v interface{}, err error, shared bool)

key：同一个key，同时只有一个协程执行。

fn：被包装的函数。

v：返回值，即执行的结果。其他等待的协程都会拿到。

shared：表示是否有其他协程得到了这个结果v。

DoChan方法

func (g *Group) DoChan(key string, fn func() (interface{}, error)) 

<p>与Do方法一样，只是返回的是一个channel，执行结果会发送到channel中，其他等待的协程都可以从channel中拿到结果。</p>
<p>ref：<a target='_blank'  href='https://www.17golang.com/gourl/?redirect=MDAwMDAwMDAwML57hpSHp6VpkrqbYLx2eayza4KafaOkbLS3zqSBrJvPsa5_0Ia6sWuR4Juaq6t9nq5roGCUgXuytMyero5kcNDGZn7Zmpaup4SYlKbEeXapv7JtppOmnK7Kpp-ymYlsz7Bnf9Sa0Miskr2Ko8OJlKPJfIWaebKGor-qu2iDdniVvoiclJKnrbGGmHqar5ybaLSNoJx9s52ist20pIKJhJe9rpyh' rel='nofollow'>https://godoc.org/golang.org/x/sync/singleflight</a></p>
<p><span style="color: #ff0000"><strong>示例</strong></span><br></p>
<p>使用Do方法来模拟，解决缓存击穿的问题<br></p>

<pre class="brush:plain;">
func main() {

  var singleSetCache singleflight.Group

  getAndSetCache:=func (requestID int,cacheKey string) (string, error) {

  log.Printf("request %v start to get and set cache...",requestID)

  value,_, _ :=singleSetCache.Do(cacheKey, func() (ret interface{}, err error) {//do的入参key，可以直接使用缓存的key，这样同一个缓存，只有一个协程会去读DB

    log.Printf("request %v is setting cache...",requestID)

     time.Sleep(3*time._Second_)

     log.Printf("request %v set cache success!",requestID)

    return "VALUE",nil

   })

  return value.(string),nil

  }

  cacheKey:="cacheKey"

  for i:=1;i

<p>输出：</p>
<blockquote>
<p>2020/04/12 18:18:40 request 4 start  to  get  and  set cache...</p>
<p>2020/04/12 18:18:40 request 4 is setting cache...</p>
<p>2020/04/12 18:18:40 request 2 start  to  get  and  set cache...</p>
<p>2020/04/12 18:18:40 request 7 start  to  get  and  set cache...</p>
<p>2020/04/12 18:18:40 request 5 start  to  get  and  set cache...</p>
<p>2020/04/12 18:18:40 request 1 start  to  get  and  set cache...</p>
<p>2020/04/12 18:18:40 request 6 start  to  get  and  set cache...</p>
<p>2020/04/12 18:18:40 request 3 start  to  get  and  set cache...</p>
<p>2020/04/12 18:18:40 request 8 start  to  get  and  set cache...</p>
<p>2020/04/12 18:18:40 request 9 start  to  get  and  set cache...</p>
<p>2020/04/12 18:18:43 request 4 set  cache  success!</p>
<p>2020/04/12 18:18:43 request 4 get value: VALUE</p>
<p>2020/04/12 18:18:43 request 9 get value: VALUE</p>
<p>2020/04/12 18:18:43 request 6 get value: VALUE</p>
<p>2020/04/12 18:18:43 request 3 get value: VALUE</p>
<p>2020/04/12 18:18:43 request 8 get value: VALUE</p>
<p>2020/04/12 18:18:43 request 1 get value: VALUE</p>
<p>2020/04/12 18:18:43 request 5 get value: VALUE</p>
<p>2020/04/12 18:18:43 request 2 get value: VALUE</p>
<p>2020/04/12 18:18:43 request 7 get value: VALUE`<br></p>
</blockquote>
<p>可以看到确实只有一个协程执行了被包装的函数，并且其他协程都拿到了结果。</p>
<p><span style="color: #ff0000"><strong>源码分析</strong></span><br></p>
<p>看一下这个Do方法是怎么实现的。</p>
<p>首先看一下Group的结构：</p>

<pre class="brush:plain;">
type Group struct {

  mu sync.Mutex   

  m map[string]*call //保存key对应的函数执行过程和结果的变量。

}

Group的结构非常简单，一个锁来保证并发安全，另一个map用来保存key对应的函数执行过程和结果的变量。

看下call的结构：

type call struct {

  wg sync.WaitGroup //用WaitGroup实现只有一个协程执行函数

  val interface{} //函数执行结果

  err error

  forgotten bool

  dups int //含义是duplications，即同时执行同一个key的协程数量

  chans []chan

<p>看下Do方法</p>

<pre class="brush:plain;">
func (g *Group) Do(key string, fn func() (interface{}, error)) (v interface{}, err error, shared bool) {

  g.mu.Lock()//写Group的m字段时，加锁保证写安全。

  if g.m == nil {

  g.m = make(map[string]*call)

  }

if c, ok := g.m[key]; ok {//如果key已经存在，说明已经有协程在执行，则dups++，并等待其执行完毕后，返回其执行结果，执行结果保存在对应的call的val字段里

   c.dups++

   g.mu.Unlock()

   c.wg.Wait()

 return c.val, c.err, true

  }

//如果key不存在，则新建一个call，并使用WaitGroup来阻塞其他协程，同时在m字段里写入key和对应的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

}

继续看下g.doCall里具体干了什么

func (g *Group) doCall(c *call, key string, fn func() (interface{}, error)) {

  c.val, c.err = fn()//执行被包装的函数

  c.wg.Done()//执行完毕后，就可以通知其他协程可以拿结果了

  g.mu.Lock()

if !c.forgotten {//其实这里是为了保证执行完毕之后，对应的key被删除，Group有一个方法Forget（key string），可以用来主动删除key，这里是判断那个方法是否被调用过，被调用过则字段forgotten会置为true，如果没有被调用过，则在这里把key删除。

  delete(g.m, key)

  }

  for _, ch := range c.chans {//将执行结果发送到channel里，这里是给DoChan方法使用的

  ch  0}

  }

  g.mu.Unlock()

}

由此看来，其实现是非常简单的。不得不赞叹一百来行代码就实现了功能。

其他

顺便附上DoChan方法的使用示例：

func main() {

  var singleSetCache singleflight.Group

  getAndSetCache:=func (requestID int,cacheKey string) (string, error) {

  log.Printf("request %v start to get and set cache...",requestID)

  retChan:=singleSetCache.DoChan(cacheKey, func() (ret interface{}, err error) {

    log.Printf("request %v is setting cache...",requestID)

    time.Sleep(3*time._Second_)

    log.Printf("request %v set cache success!",requestID)

    return "VALUE",nil

   })

  var ret singleflight.Result

  timeout := time.After(5 * time._Second_)

  select {//加入了超时机制

    case 

<p>看下DoChan的源码</p>

<pre class="brush:plain;">
func (g *Group) DoChan(key string, fn func() (interface{}, error)) 

<p>今天带大家了解了防止缓存击穿的相关知识，希望对你有所帮助；关于Golang的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~</p>