singleflight解决缓存击穿与源码分析

已于 2022-01-19 22:06:12 修改
阅读量853 收藏 2
点赞数
分类专栏： 面试题 文章标签： 缓存 数据库 golang 服务器
于 2022-01-19 22:05:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42956653/article/details/122589497
版权

singleflight解决缓存击穿与源码细节

缓存击穿

在高并发的场景下，出现同一时刻有大量的请求同时查询一个key时，恰好在这个时候这个缓存key过期失效了，那么这些大量的请求转发到数据库DB上，高并发的对这一个key进行请求，就像水滴石穿一样，瞬间请求量给到DB，可能会把DB打死。

解决办法：

  1. 让热key永远不过期，定期去刷新数据就可以了。
  2. 为了避免出现缓存击穿的情况，可以在第一个请求去查询数据库的时候对他加一个互斥锁，其余的查询请求都会被阻塞住，直到锁被释放，后面的线程进来发现已经有缓存了，就直接走缓存，从而保护数据库。但是也是由于它会阻塞其他的线程，颗粒很大，此时系统吞吐量会下降。需要结合实际的业务去考虑是否要这么做。
  3. singleflight的设计思路，也会使用互斥锁，但是相对于方法二的加锁粒度会更细。将一组相同的请求合并成一个请求，使用map存储，只会有一个请求到达mysql，使用sync.waitgroup进行同步，对所有的请求返回相同的结果。
    在这里插入图片描述

模拟演示

被击穿

package main

import (
	"errors"
	"log"
	"sync"
)

var errorNotExist = errors.New("not exist")

func main() {
	var wg sync.WaitGroup
	//模拟10个并发
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			data, err := getData("key")
			if err != nil {
				log.Print(err)
				return
			}
			log.Println(data)
		}()
	}
	wg.Wait()
}

//获取数据
func getData(key string) (string, error) {
	data, err := getDataFromCache(key)
	if err == errorNotExist {
		//模拟从db中获取数据
		data, err = getDataFromDB(key)
		if err != nil {
			log.Println(err)
			return "", err
		}
		//TODO set cache
	} else if err != nil {
		return "", err
	}
	return data, nil
}

//模拟从cache中获取值，cache中无该值
func getDataFromCache(key string) (string, error) {
	return "", errorNotExist
}

//模拟从数据库中获取值
func getDataFromDB(key string) (string, error) {
	log.Printf("get %s from database", key)
	return "data", nil
}

其中通过 getData(key) 获取数据， 逻辑是

  1. 先尝试从cache中获取
  2. 如果cache中不存在就从db中获取

模拟了10个并发请求，来同时调用 getData 函数，执行结果如下

2022/01/19 21:03:04 get key from database
2022/01/19 21:03:04 data
2022/01/19 21:03:04 get key from database
2022/01/19 21:03:04 data
2022/01/19 21:03:04 get key from database
2022/01/19 21:03:04 data
2022/01/19 21:03:04 get key from database
2022/01/19 21:03:04 data
2022/01/19 21:03:04 get key from database
2022/01/19 21:03:04 data
2022/01/19 21:03:04 get key from database
2022/01/19 21:03:04 data
2022/01/19 21:03:04 get key from database
2022/01/19 21:03:04 data
2022/01/19 21:03:04 get key from database
2022/01/19 21:03:04 data
2022/01/19 21:03:04 get key from database
2022/01/19 21:03:04 data
2022/01/19 21:03:04 get key from database
2022/01/19 21:03:04 data

进程 已完成，退出代码为 0

可以看得到10个请求都是走的db，因为cache中不存在该值

singleflight解决

对getData稍微改动一下

package main

import (
	"errors"
	"golang.org/x/sync/singleflight"
	"log"
	"sync"
)

var errorNotExist = errors.New("not exist")
var g singleflight.Group

func main() {
	var wg sync.WaitGroup
	//模拟10个并发
	for i := 0; i < 100; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			data, err := getData("key")
			if err != nil {
				log.Print(err)
				return
			}
			log.Println(data)
		}()
	}
	wg.Wait()
}

//获取数据
func getData(key string) (string, error) {
	data, err := getDataFromCache(key)
	if err == errorNotExist {
		//模拟从db中获取数据
		value, err, _ := g.Do(key, func() (interface{}, error) {
			return getDataFromDB(key)
			//set cache
		})
		if err != nil {
			log.Println(err)
			return "", err
		}
		//TODO: set cache
		data = value.(string)
	} else if err != nil {
		return "", err
	}
	return data, nil
}

//模拟从cache中获取值，cache中无该值
func getDataFromCache(key string) (string, error) {
	return "", errorNotExist
}

//模拟从数据库中获取值
func getDataFromDB(key string) (string, error) {
	log.Printf("get %s from database", key)
	return "data", nil
}

执行结果如下，可以看得到只有一个请求进入的DB，其他的请求也正常返回了值，从而保护了DB。

2022/01/19 21:16:48 get key from database
2022/01/19 21:16:48 data
2022/01/19 21:16:48 data
2022/01/19 21:16:48 data
2022/01/19 21:16:48 data
2022/01/19 21:16:48 data
2022/01/19 21:16:48 data
2022/01/19 21:16:48 data
2022/01/19 21:16:48 data
2022/01/19 21:16:48 data
2022/01/19 21:16:48 data

进程 已完成，退出代码为 0

源码分析

//Do方法，传入key，以及回调函数，如果key相同，fn方法只会执行一次，同步等待
//返回值v:表示fn执行结果
//返回值err:表示fn的返回的err
//第三个返回值shared：表示是否是真实fn返回的还是从保存的map[key]返回的，也就是共享的
func (g *Group) Do(key string, fn func() (interface{}, error)) (v interface{}, err error, shared bool) 
//DoChan方法类似Do方法，只是返回的是一个chan
func (g *Group) DoChan(key string, fn func() (interface{}, error)) <-chan Result 
//Forget方法控制key关联的值是否失效，默认以上两个方法只要fn方法执行完成后，内部维护的fn的值也删除（即并发结束后就失效了）
func (g *Group) Forget(key string)

singleflight的数据结构：

type Group struct {
	mu sync.Mutex       // 互斥锁，保证并发安全
	m  map[string]*call // 存储相同的请求，key是相同的请求，value保存返回的信息。
}
type call struct {
	wg sync.WaitGroup
	// 存储返回值
	val interface{}
	// 存储返回的错误信息
	err error
	// 标识别是否调用了Forgot方法
	forgotten bool
	// 统计相同请求的次数
	dups int
	// 使用DoChan方法使用，用channel进行通知
	chans []chan<- Result
}

// Dochan方法时使用
type Result struct {
	Val    interface{} // 存储返回值
	Err    error       // 存储返回的错误信息
	Shared bool        // 标示结果是否是共享结果
}

func (g *Group) Do(key string, fn func() (interface{}, error)) (v interface{}, err error, shared bool) {
	// 代码块加锁
	g.mu.Lock()
	// map进行懒加载
	if g.m == nil {
		// map初始化
		g.m = make(map[string]*call)
	}
	// 判断是否有相同请求
	if c, ok := g.m[key]; ok {
		// 相同请求次数+1
		c.dups++
		// 解锁就好了，只需要等待执行结果了，不会有写入操作了
		g.mu.Unlock()
		// 已有请求在执行，只需要等待就好了
		c.wg.Wait()
		// 区分panic错误和runtime错误
		if e, ok := c.err.(*panicError); ok {
			panic(e)
		} else if c.err == errGoexit {
			runtime.Goexit()
		}
		return c.val, c.err, true
	}
	// 之前没有这个请求，则需要new一个指针类型
	c := new(call)
	// sync.WaitGroup的用法，只有一个请求运行，其他请求等待，所以只需要add(1)
	c.wg.Add(1)
	// m赋值
	g.m[key] = c
	// 没有写入操作了，解锁即可
	g.mu.Unlock()
	// 唯一的请求该去执行函数了
	g.doCall(c, key, fn)
	return c.val, c.err, c.dups > 0
}

// doCall handles the single call for a key.
func (g *Group) doCall(c *call, key string, fn func() (interface{}, error)) {
	// 标识是否正常返回
	normalReturn := false
	// 标识别是否发生panic
	recovered := false

	defer func() {
		// 通过这个来判断是否是runtime导致直接退出了
		if !normalReturn && !recovered {
			// 返回runtime错误信息
			c.err = errGoexit
		}
		c.wg.Done()
		g.mu.Lock()
		defer g.mu.Unlock()
		// 防止重复删除key
		if !c.forgotten {
			delete(g.m, key)
		}
		// 检测是否出现了panic错误
		if e, ok := c.err.(*panicError); ok {
			// 如果是调用了dochan方法，为了channel避免死锁，这个panic要直接抛出去，不能recover住，要不就隐藏错误了
			if len(c.chans) > 0 {
				go panic(e) // 开一个写成panic
				select {}   // 保持住这个goroutine，这样可以将panic写入crash dump
			} else {
				panic(e)
			}
		} else if c.err == errGoexit {
			// runtime错误不需要做任何时，已经退出了
		} else {
			// 正常返回的话直接向channel写入数据就可以了
			for _, ch := range c.chans {
				ch <- Result{c.val, c.err, c.dups > 0}
			}
		}
	}()
	// 使用匿名函数目的是recover住panic，返回信息给上层
	func() {
		defer func() {
			if !normalReturn {
				// 发生了panic，我们recover住，然后把错误信息返回给上层
				if r := recover(); r != nil {
					c.err = newPanicError(r)
				}
			}
		}()
		// 执行函数
		c.val, c.err = fn()
		// fn没有发生panic
		normalReturn = true
	}()
	// 判断执行函数是否发生panic
	if !normalReturn {
		recovered = true
	}
}
//异步返回
// 入参数：key：标识相同请求，fn：要执行的函数
// 出参数：<- chan 等待接收结果的channel
func (g *Group) DoChan(key string, fn func() (interface{}, error)) <-chan Result {
	// 初始化channel
	ch := make(chan Result, 1)
	g.mu.Lock()
	// 懒加载
	if g.m == nil {
		g.m = make(map[string]*call)
	}
	// 判断是否有相同的请求
	if c, ok := g.m[key]; ok {
		//相同请求数量+1
		c.dups++
		// 添加等待的chan
		c.chans = append(c.chans, ch)
		g.mu.Unlock()
		return ch
	}
	c := &call{chans: []chan<- Result{ch}}
	c.wg.Add(1)
	g.m[key] = c
	g.mu.Unlock()
	// 开一个写成调用
	go g.doCall(c, key, fn)
	// 返回这个channel等待接收数据
	return ch
}

// 释放某个 key 下次调用就不会阻塞等待了
func (g *Group) Forget(key string) {
	g.mu.Lock()
	if c, ok := g.m[key]; ok {
		c.forgotten = true
	}
	delete(g.m, key)
	g.mu.Unlock()
}

注意事项

在使用singleflight时需要自己写回调函数，但是如果回调函数里面一直循环，那么相同请求就会阻塞在那里，需要特别注意

value, err, _ := g.Do(key, func() (interface{}, error) {
	for{
		
	}
})

singleflight Do方法原理总结

在Do方法中主要是通过waitgroup来控制的，主要流程如下：

  1. 设置一个map，如果key不存在，则创建一个*call，存入map中

  2. 如果已经在调用中key已存在map中，则wg.Wait等待第一个去DB的请求回来

  3. 第一个去DB的执行回调函数结束之后，在doCall方法中执行wg.Done，此时所有wg.Wait的协程都将继续执行

DoChan方法也是类似的逻辑，只是返回的是一个chan。

Golang源码：singleflight分析(一)
飞越蓝天的专栏
10-24 443
wg . Add(10) //模拟10个并发 for i := 0;i < 10;i ++ {= nil {log . Print(err) return } log . Println(data) }() } wg . Wait() } //获取数据 func getData(key string)(string , error) {//模拟从db中获取数据 data , err = getDataFromDB(key) if err!
Golang源码：singleflight分析(二)
飞越蓝天的专栏
10-31 318
Group结构只有两个字段，m是一个map，key是相同请求的标识，value是用来保存调用信息，这个map是懒加载，就是在使用时才会初始化；mu是互斥锁，用来保证m的并发安全。wg sync . WaitGroup // 存储返回值，在wg done之前只会写入一次 val interface {
缓存击穿了怎么办？使用singleflight轻松解决！
Viper的程序员修炼手册
07-21 545
singleflight使用场景 缓存击穿：缓存在某个时间点过期的时候，恰好在这个时间点对这个Key有大量的并发请求过来，这些请求发现缓存过期一般都会从后端DB加载数据并回设到缓存，这个时候大并发的请求可能会瞬间把后端DB压垮。 绝大多数公司都是这么用的 请求资源去重复 我们的用法，需要改动一行代码。 singleflight 简介 singleflight 在 golang.org/x/sync/singleflight 项目下，对外提供了以下几个方法 //Do方法，传入key，以及回调函
groupcache源码分析（四）-- singleflight
Mr.Buffoon
11-06 1110
singleflight.go文件中是singleflight模块的代码，这主要是进行相同访问的一个合并操作。也就是说，如果对于某个key的请求已经存在并且正在进行，则对该key的新的请求会堵塞在这里，等原来的请求结束后，将请求得到的结果同时返回给堵塞中的请求。 该部分就封装了一个接口： func (g *Group) Do(key string, fn func() (interface{}, ...
【Go | 从0实现简单分布式缓存】-4：使用singleflight防止缓存击穿
theaipower的博客
02-26 1106
主要介绍如何使用singlefligth防止缓存击穿，途中涉及到了一些经典的函数，比如协程的wg.WaitGroup()函数应该在协程之间不需要消息传递的时候非常适用，还有对应的匿名函数的作用原理。
【缓存击穿】Java的“SingleFlight”解决方案
最新发布
weixin_42430947的博客
04-07 435
Golang中的SingleFlight能很好地解决缓存击穿问题
基于single flight来解决缓存击穿
zhanghailang1的博客
06-17 961
基于single flight的方式解决缓存击穿
single flight防止缓存击穿
写写代码
12-07 668
什么是缓存击穿 我们常说的缓存问题：缓存雪崩，缓存击穿，缓存穿透都分别指什么呢？ 简单来说： 缓存雪崩是指缓存在同一时间全部失效，导致压力全部转移到DB上。 缓存击穿指的是某个key在失效的这一刻，有大量的请求数据，这些数据压力也转移到了DB。 缓存穿透指的是大量数据访问一个不存在的key，导致每次都必须请求DB，DB压力过大。 如何减少瞬间压力 像缓存雪崩这种现象，一般是由于缓存服务器宕机（key哈希失效），大量的key设置了相同失效时间导致。可以通过哈希环或者人为控制key的失效时间来避免。
深入解析go 缓存击穿方案-singleflight
白日梦程序员的博客
09-21 518
1.问题 描述：某一个热点 key，在缓存过期的一瞬间，同时有大量的请求打进来，由于此时缓存过期了，所以请求最终都会走到数据库，造成瞬时数据库请求量大、压力骤增，甚至可能打垮数据库。 曾经有面试官问我这个问题，我将解决方法说了，然后提到singleflight ，问我源码，一时语塞(▼皿▼#)，只能说曾经看过，所以写下这篇文章，记录一下。 2.解决方法 给key设置随机过期时间 让多个请求请求数据库只有一个连接成功（singleflight 实现思路） 3.singlefli
Golang源码分析之golang/sync之singleflight
dz45693的专栏
11-04 964
golang/sync库拓展了官方自带的sync库，提供了errgroup、semaphore、singleflight及syncmap四个包，本次分析singlefliht的源代码。singlefliht用于解决单机协程并发调用下的重复调用问题，常与缓存一起使用，避免缓存击穿。singleflight经常和缓存获取配合使用，可以缓解缓存击穿问题，避免同一时刻单机大量的并发调用获取数据库构建缓存。
Golang 实战知识库：从单例模式到微服务实战
24. **golang singleflight**：singleflight是Go标准库中的一个组件，用于防止缓存击穿，优化并发请求。 25. **golang程序异常退出处理**：讨论如何优雅地处理Go程序的退出，确保资源的正确释放和错误处理。 这个...
Go 高性能 - singleflight 防止缓存击穿
Go中国
05-29 289
概述Go 语言扩展包中提供了另一种同步原语singleflight，它能够抑制对某个 API 的多次重复请求。举个简单的例子：使用Redis缓存数据库数据，当发生缓存击穿时，请求会全部落到数据库上，轻则影响数据库性能，重则造成数据库直接宕机。通过singleflight原语，可以简单有效地解决这个问题，通过限制同一个key的重复请求，避免请求全部落到数据库，减少性能影响和宕机风险...
GO singleflight 你真的会用吗？「源码分析+详细案例」
pengyachuan的博客
02-22 1177
缓存在项目中使用应该是非常频繁的，提到缓存只要了解过 singleflight ，基本都会用于缓存实现的一部分吧？
泛型版 singleflight：Go 中如何防止缓存击穿？
Seekload
02-22 282
阅读本文大概需要 5 分钟。大家好，我是 polarisxu。并发是 Go 的优势，但并发也需要很好的进行控制。标准库中有 sync 包，经常使用的功能有 sync.Mutex、sync....
缓解缓存击穿的大杀器之---singleflight深入浅出
qq_51898139的博客
11-06 679
singlefight直译“单飞”，那顾名思义就是有一堆鸟，但是咱只让一只鸟单飞。。。😄提供了重复函数调用抑制机制，使用它可以避免同时进行相同的函数调用。第一个调用未完成时后续的重复调用会等待，当第一个调用完成时则会与它们分享结果，这样以来虽然只执行了一次函数调用但是所有调用都拿到了最终的调用结果。
如何防止缓存被击穿
DTCloud
05-26 103
这两个方法的缺点在哪里？使用全局变量和channel，在独立开发的条件下是可以的。但是，一旦到了团队协同开发，需要统一所有开发者的编码习惯。需要一个共同的解决方案。
singleflight在缓存击穿中的应用（缓存穿透、缓存雪崩、缓存击穿的介绍，以及go版源码赏析）
weixin_43716964的博客
01-09 481
singleflight在缓存击穿中的应用（缓存穿透、缓存雪崩、缓存击穿的介绍，golang版源码赏析）
Go缓存击穿方案-singleflight源码解读
阿星君
06-16 592
在缓存击穿及解决方案中简单介绍了Go使用singleflight解决缓存击穿，查到了singleflight的源码，阅读感受只能说“让我感觉自己不太适合干程序员这项工作~”，今天下决心把singleflight源码搞懂，尤其是前几天一直困惑的singleflight何时存储，何时删除其内部缓存的问题。 而且，其中涉及到了很多Go的并发编程知识。很有必要学习一番。 Go并发的一些知识 WaitGroup 等待线程组 WaitGroup线程同步，指等待一组协程goroutine执行完成后才会继...
Go singleflight 第三方库在防止缓存击穿中的重要作用
梦~'
03-28 1198
Go singleflight 第三方库在防止缓存击穿中的重要作用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

cheems~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值