【go项目-geecache】动手写分布式缓存 - day6 - 防止缓存击穿

CCSU__LRF

已于 2023-04-20 08:55:50 修改

阅读量797

点赞数 2

分类专栏： golang项目 - geecache 文章标签：缓存 golang 分布式

于 2023-04-19 15:06:33 首次发布

本文链接：https://blog.csdn.net/csxylrf/article/details/130244567

版权

golang项目 - geecache 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

索引

【go项目-geecache】动手写分布式缓存 - day1 - 实现LRU算法
 【go项目-geecache】动手写分布式缓存 - day2 - 单机并发缓存
 【go项目-geecache】动手写分布式缓存 - day3 - HTTP 服务端
 【go项目-geecache】动手写分布式缓存 - day4 - 一致性哈希(hash)
【go项目-geecache】动手写分布式缓存 - day5 - 分布式节点
 【go项目-geecache】动手写分布式缓存 - day6 - 防止缓存击穿
 【go项目-geecache】动手写分布式缓存 - day7 - 使用 Protobuf 通信

收获

了解缓存穿透，缓存雪崩，缓存击穿
知道怎么防止缓存击穿
了解匿名函数的使用
加深了锁的使用
了解空接口interface{}和模板的区别和作用

介绍缓存穿透，缓存雪崩，缓存击穿

概念可以看我这篇博客缓存穿透，缓存雪崩，缓存击穿概念及解决方法
简单说一下缓存击穿，就是在缓存中找不到数据，导致直接访问数据库，降低效率

为什么我们要防止缓存击穿

当前我们所做的项目对数据库的访问没有做任何限制的，所以当客户端发起大量请求，很容易导致缓存击穿和穿透，所以我们需要减少重复请求

引入singleflight

singleflight是一种用于减少重复请求的技术，它可以避免在高并发场景下出现重复的请求。
singleflight的实现方式是在请求前先检查是否已经有相同的请求正在处理，如果有，则等待该请求的处理结果并直接返回，避免重复发起请求。

实现singleflight数据结构

package singleflight  
  
import "sync"  
  
type call struct {  
	wg  sync.WaitGroup  
	val interface{}  
	err error  
}  
  
type Group struct {  
	mu sync.Mutex       // protects m  
	m  map[string]*call  
}

call：表示正在进行中，或已经完成的函数调用，其中wg字段是sync.WaitGroup 锁避免冲突，val字段是一个空接口，err字段表示函数调用是否发生了错误。
Group：表示一组正在进行中的函数调用，其中mu字段是一个互斥锁，用于保护m字段的读写，m字段是一个map，用于存储正在进行中的函数调用

这里我对sync.WaitGroup和interface{} 空接口解释一下：

`sync.WaitGroup`

用于等待一组goroutine执行完成。主要用于在主goroutine等待一组子goroutine执行完毕后再继续执行的场景。

`interface{}` 空接口

我们知道接口时一组方法的集合，接口类型定义了一组方法，但没有实现这些方法。空接口里面没有方法，意味着它可以表示任意类型的值，可以方便地实现通用性较强的函数或数据结构

空接口和模板的区别

空接口的类型判断需要通过断言，而模板的数据类型是利用编译器进行类型推导来获得的
模板在使用时需要在编译阶段进行类型检查，因此可以保证类型安全性

实现singleflight的Do方法

func (g *Group) Do(key string, fn func() (interface{}, error)) (interface{}, error) {  
	g.mu.Lock()  
	if g.m == nil {  
		g.m = make(map[string]*call)  
	}  
	if c, ok := g.m[key]; ok {  
		g.mu.Unlock()  
		c.wg.Wait()  
		return c.val, c.err  
	}  
	c := new(call)  
	c.wg.Add(1)  
	g.m[key] = c  
	g.mu.Unlock()  
  
	c.val, c.err = fn()  
	c.wg.Done()  
  
	g.mu.Lock()  
	delete(g.m, key)  
	g.mu.Unlock()  
  
	return c.val, c.err  
}

Do() : 这个函数传入key和函数fn，只要key相同，那么fn函数指挥运行一次

首先mutex锁，防止g.m并发读写冲突
检查group的m成员变量是否存在，不存在则初始化
检查key的请求是否正在执行，如果正在执行，则等待结果并解锁，等待结果后返回结果
否则如果没有在执行，新建一个call类型表示正在执行
发起请求前加锁
将这个call加入到group的m（map）中，表示正在执行
调用fn
c.wg.Done() 表示请求结束
group的m（map）中从删除call

把singleflight加入主进程group.go

type Group struct {  
	name      string  
	getter    Getter  
	mainCache cache  
	peers     PeerPicker  
	
	loader *singleflight.Group  
}  
  
func NewGroup(name string, cacheBytes int64, getter Getter) *Group {  
	g := &Group{  
		loader:    &singleflight.Group{},  
	}  
	return g  
}  
  
func (g *Group) load(key string) (value ByteView, err error) {  
	viewi, err := g.loader.Do(key, func() (interface{}, error) {  
		if g.peers != nil {  
			if peer, ok := g.peers.PickPeer(key); ok {  
				if value, err = g.getFromPeer(peer, key); err == nil {  
					return value, nil  
				}  
				log.Println("[GeeCache] Failed to get from peer", err)  
			}  
		}  
		return g.getLocally(key)  
	})  
	if err == nil {  
		return viewi.(ByteView), nil  
	}  
	return  
}

添加Group结构体loader，更新NewGroup
修改load函数，使用匿名函数保证对于同一个key只会执行一次

测试

$ ./run.sh  
2020/02/16 22:36:00 [Server http://localhost:8003] Pick peer http://localhost:8001  
2020/02/16 22:36:00 [Server http://localhost:8001] GET /_geecache/scores/Tom  
2020/02/16 22:36:00 [SlowDB] search key Tom  
630630630

更新后的group.go

// 负责与外部交互，控制缓存存储和获取的主流程
package geecache

import (
	"fmt"
	"geecache/singleflight"
	"log"
	"sync"
)

type Group struct {
	name      string
	getter    Getter
	mainCache cache
	peers     PeerPicker

	loader *singleflight.Group
}

type Getter interface {
	Get(key string) ([]byte, error)
}

type GetterFunc func(key string) ([]byte, error)

func (f GetterFunc) Get(key string) ([]byte, error) {
	return f(key)
}

var (
	mu     sync.RWMutex
	groups = make(map[string]*Group)
)

func NewGroup(name string, cacheBytes int64, getter Getter) *Group {
	if getter == nil {
		panic("nil Getter")
	}
	mu.Lock()
	defer mu.Unlock()
	g := &Group{
		name:      name,
		getter:    getter,
		mainCache: cache{cacheBytes: cacheBytes},
		loader:    &singleflight.Group{},
	}
	groups[name] = g
	return g
}

func GetGroup(name string) *Group {
	mu.RLock()
	g := groups[name]
	mu.RUnlock()
	return g
}

func (g *Group) Get(key string) (ByteView, error) {
	if key == "" {
		return ByteView{}, fmt.Errorf("key is required")
	}

	if v, ok := g.mainCache.get(key); ok {
		log.Println("[GeeCache] hit")
		return v, nil
	}

	return g.load(key)
}

func (g *Group) getLocally(key string) (ByteView, error) {
	bytes, err := g.getter.Get(key)
	if err != nil {
		return ByteView{}, err

	}
	value := ByteView{b: cloneBytes(bytes)}
	g.populateCache(key, value)
	return value, nil
}

func (g *Group) populateCache(key string, value ByteView) {
	g.mainCache.add(key, value)
}
func (g *Group) RegisterPeers(peers PeerPicker) {
	if g.peers != nil {
		panic("RegisterPeerPicker called more than once")
	}
	g.peers = peers
}

func (g *Group) load(key string) (value ByteView, err error) {
	// each key is only fetched once (either locally or remotely)
	// regardless of the number of concurrent callers.
	viewi, err := g.loader.Do(key, func() (interface{}, error) {
		if g.peers != nil {
			if peer, ok := g.peers.PickPeer(key); ok {
				if value, err = g.getFromPeer(peer, key); err == nil {
					return value, nil
				}
				log.Println("[GeeCache] Failed to get from peer", err)
			}
		}

		return g.getLocally(key)
	})

	if err == nil {
		return viewi.(ByteView), nil
	}
	return
}

func (g *Group) getFromPeer(peer PeerGetter, key string) (ByteView, error) {
	bytes, err := peer.Get(g.name, key)
	if err != nil {
		return ByteView{}, err
	}
	return ByteView{b: bytes}, nil
}