go 进阶 go-zero相关: 十. redis与缓存高级

苹果香蕉西红柿

已于 2023-06-28 18:13:10 修改

阅读量977

点赞数

分类专栏： # 十四. go-zero底层原理与基本使用文章标签： redis 缓存 golang

于 2023-05-11 16:04:26 首次发布

本文链接：https://blog.csdn.net/qq_29799655/article/details/128883712

版权

十四. go-zero底层原理与基本使用专栏收录该内容

10 篇文章 12 订阅

订阅专栏

一. 基础

go-zero内部提供了redis操作相关的包,基础操作示例

import (
	"fmt"
	"github.com/zeromicro/go-zero/core/stores/redis"
)

func test() {
	//1.获取redis连接
	redisObj := redis.New("addr")
	//2.设置数据
	key := "abc"
	err := redisObj.Set(key, "123erf")
	if err != nil {
		fmt.Printf("set fail:%v\n", err)
	}
	//3.获取数据
	res, err := redisObj.Get(key)
	if err != nil {
		fmt.Printf("get fail:%v\n", err)
	}
	fmt.Printf("result:%s", res)
}

并且通过在上一章"go 进阶 go-zero相关: 八. goctl 生成数据库与缓存逻辑" 我们了解到go-zero默认提供了缓存model数据功能, 在执行goctl命令生成数据库crud mudel时增加"-c"指令即可,go-zero中提供了cache.CacheConf,在底层通过该结构连接缓存组件,进行缓存的增删改查操作

goctl model mysql datasource -url="root:root@tcp(127.0.0.1:3306)/demo" -table="t_user" -dir="./model" -c -style goZero

接下来我们了解一下go-zero中缓存相关的高级用法

二. 进程内缓存组件 collection.Cache

参考博客
go-zero 提供的简单的缓存封装 collection.Cache,通过该组件可以实现(注意这里说的缓存不是redis):

缓存增删改，自动失效，可以指定过期时间
缓存大小限制，可以指定缓存个数，有LRU算法
缓存命中率统计
并发安全，解决缓存击穿问题

基础使用示例

import (
	"github.com/zeromicro/go-zero/core/collection"
	"time"
)

func test2() {
	// 初始化 cache，其中 WithLimit 可以指定最大缓存的数量
	c, err := collection.NewCache(time.Minute, collection.WithLimit(10000))
	if err != nil {
		panic(err)
	}
	// 设置缓存
	c.Set("key", "aaaa")
	// 获取缓存，ok：是否存在
	v, ok := c.Get("key")
	// 删除缓存
	c.Del("key")
	// 获取缓存，如果 key 不存在的，则会调用 func 去生成缓存
	v, err := c.Take("key", func() (interface{}, error) {
		return "vvvv", nil
	})
}

原理相关

1. 初始化collection.Cache

调用NewCache()初始化方法,会返回一个Cache数据结构

func NewCache(expire time.Duration, opts ...CacheOption) (*Cache, error) {
	cache := &Cache{//声明缓存结构，初始化内容
		data:           make(map[string]interface{}),
		expire:         expire,
		lruCache:       emptyLruCache, //默认是一个空的LRU结构，可以通过opts来控制
		barrier:        syncx.NewSingleFlight(),//解决缓存击穿的核心方法
		unstableExpiry: mathx.NewUnstable(expiryDeviation),//框架自己做的一个并发安全的随机数
	}

	for _, opt := range opts {
		opt(cache) //执行预加载函数
	}

 ...
	cache.stats = newCacheStat(cache.name, cache.size)//缓存命中统计模块，初始化

	timingWheel, err := NewTimingWheel(time.Second, slots, func(k, v interface{}) {
		key, ok := k.(string)
		if !ok {
			return
		}

		cache.Del(key)
	})//定时器模块，初始化
	...
	return cache, nil
}

在Cache 结构中有三块比较重要:

lruCache: Cache有大小限制, 通过LRU淘汰策略管理大小的
barrier: 用来解决缓存击穿的核心方法
unstableExpiry: 框架自己做的一个并发安全的随机数

type (
	CacheOption func(cache *Cache) //用来操作缓存的函数，用在实例化缓存时

	Cache struct {
		name           string //缓存名称
		lock           sync.Mutex //并发锁
		data           map[string]interface{} //缓存内容
		expire         time.Duration //过期时间
		timingWheel    *TimingWheel //框架封装的定时器
		lruCache       lru //LRU组件
		barrier        syncx.SingleFlight //缓存并发安全组件，可以解决缓存击穿的问题
		unstableExpiry mathx.Unstable //生成随机数的插件
		stats          *cacheStat //统计命中率模块
	}
)

2. 增删改查方法

这一块代码大同小异，都是加锁，操作，再解锁的方式来进行并发管理的。通过这一块代码的阅读，基本可以明确LRU模块和命中率统计模块是如何工作的


func (c *Cache) Del(key string) {
	c.lock.Lock() //上锁
	delete(c.data, key) // 删除元素
	c.lruCache.remove(key) //移除LRU
	c.lock.Unlock() // 解锁
	c.timingWheel.RemoveTimer(key) //移除定时器， 注意先解锁，后移除。
}

func (c *Cache) Get(key string) (interface{}, bool) {
	...
	if ok { //统计命中率
		c.stats.IncrementHit()
	} else {
		c.stats.IncrementMiss()
	}
  ...
}


func (c *Cache) Set(key string, value interface{}) {
	c.lock.Lock() //上锁
	_, ok := c.data[key] //判断KEY是否存在
	c.data[key] = value //赋值
	c.lruCache.add(key) //添加到LRU
	c.lock.Unlock() //解锁

	expiry := c.unstableExpiry.AroundDuration(c.expire) //设置过期值
	if ok {
		c.timingWheel.MoveTimer(key, expiry)
	} else {
		c.timingWheel.SetTimer(key, value, expiry)
	}
}	

func (c *Cache) doGet(key string) (interface{}, bool) {
 	...
	value, ok := c.data[key]
	if ok {
		c.lruCache.add(key) //添加到LRU中
	}
 ...
}

3. 获取指定key值时解决缓存击穿

在通过Take()方法获取指定KEY值,如果不存在,执行fetch方法,拿到返回值设置到缓存里,并返回。当出现并发情况时，barrier方法会保证并发安全

func (c *Cache) Take(key string, fetch func() (interface{}, error)) (interface{}, error) {
	if val, ok := c.doGet(key); ok {//直接获取KEY的值
		c.stats.IncrementHit() //记录命中
		return val, nil
	}

	var fresh bool
	//核心方法，主要是用了syncx.NewSharedCalls实现的功能
	val, err := c.barrier.Do(key, func() (interface{}, error) {
		//这里进行了一次dobble check。解决并发时，有些协程可能已经把数据查出来并加载到缓存了。
		if val, ok := c.doGet(key); ok {
			return val, nil
		}

		v, e := fetch()//执行方法，获取CACHE。这个方法应该尽量的保证效率
		if e != nil {
			return nil, e
		}

		fresh = true
		c.Set(key, v) //设置缓存
		return v, nil
	})
 	...

	if fresh {
		//fetch 获取到数据为空，记录miss次数
		c.stats.IncrementMiss()
		return val, nil
	}

	// 直接把之前查到的数据返回，并记录命中次数
	c.stats.IncrementHit()
	return val, nil
}

这里实现缓存击穿安全的方法主要是依赖了syncx.NewSharedCalls, 使用SharedCalls可以使得同时多个请求只需要发起一次拿结果的调用,其它请求等待,有效减少了资源服务的并发压力,可以有效防止缓存击穿(下面会专门介绍NewSharedCalls)

LRU的淘汰算法

通过collection.Cache引出 go-zero中提供的LRU淘汰算法, LRU的核心思想：

新数据插入到链表头部；
每当缓存命中（即缓存数据被访问），则将数据移到链表头部；
当链表满的时候，将链表尾部的数据丢弃

type (
	lru interface { //声明一个接口
		add(key string)
		remove(key string)
	}

	emptyLru struct{} //默认的空结构，newCache的时候默认用的就这个

	keyLru struct {//带有限制的结构，ewCache的时候通过调用withLimit方法设置
		limit    int //总长度
		evicts   *list.List //元素链
		//存放的是元素在链表中的地址。利用MAP操作O1的特性，不用遍历链表即可找到需要的元素的地址。
		elements map[string]*list.Element
		onEvict  func(key string) //删除的后置操作
	}
)

//使用时调用该方法初始化keyLru 
func newKeyLru(limit int, onEvict func(key string)) *keyLru {
...
}

func (klru *keyLru) add(key string) {
	if elem, ok := klru.elements[key]; ok {
		klru.evicts.MoveToFront(elem)//如果新增元素已存在，就直接移到最前面
		return
	}

	elem := klru.evicts.PushFront(key)//在链表最前面增加一个元素
	klru.elements[key] = elem //记录这个元素的地址

	if klru.evicts.Len() > klru.limit {
		klru.removeOldest()//如果链表的最大长度超过配置，移除最老的元素
	}
}

func (klru *keyLru) remove(key string) {
...
}

func (klru *keyLru) removeOldest() {
	elem := klru.evicts.Back()//取链表最后一个元素
	if elem != nil {
		klru.removeElement(elem) //移除元素
	}
}

func (klru *keyLru) removeElement(e *list.Element) {
	klru.evicts.Remove(e)//移除链表中的元素
	key := e.Value.(string)//获取Key
	delete(klru.elements, key)//移除MAP中的元素
	klru.onEvict(key) //执行删除的后置操作
}

命中统计模块

在上方初始化cache时,会调用newCacheStat()初始化命中统计模块,源码如下:

type cacheStat struct {
	name         string //名称，最后打印日志记录是要用到
	hit          uint64 //命中缓存次数
	miss         uint64 //未命中次数
	sizeCallback func() int //自定义回调函数，会在打印结果的时候用到
}

func newCacheStat(name string, sizeCallback func() int) *cacheStat {...}

func (cs *cacheStat) IncrementHit() {
	atomic.AddUint64(&cs.hit, 1) //记录命中次数
}

func (cs *cacheStat) IncrementMiss() {
	atomic.AddUint64(&cs.miss, 1)
}

func (cs *cacheStat) statLoop() {
...
}

三. 防止缓存击穿之进程内共享调用

参考博客
并发场景下,可能会有多个线程(协程)同时请求同一份资源,如果每个请求都要走一遍资源的请求过程,除了比较低效之外,还会对资源服务造成并发的压力,比如缓存失效
go-zero中提供了syncx.NewSharedCalls()解决这个问题, 在上方cache中也有调用这个方法
使用示例:(github.com/tal-tech/go-zero/core/syncx 版本的)

func main() {
  const round = 5
  var wg sync.WaitGroup
  barrier := syncx.NewSharedCalls()
  wg.Add(round)
  for i := 0; i < round; i++ {
    // 多个线程同时执行
    go func() {
      defer wg.Done()
      // 可以看到，多个线程在同一个key上去请求资源，获取资源的实际函数只会被调用一次
      val, err := barrier.Do("once", func() (interface{}, error) {
        // sleep 1秒，为了让多个线程同时取once这个key上的数据
        time.Sleep(time.Second)
        // 生成了一个随机的id
        return stringx.RandId(), nil
      })
      if err != nil {
        fmt.Println(err)
      } else {
        fmt.Println(val)
      }
    }()
  }
  wg.Wait()
}

"github.com/zeromicro/go-zero/core/syncx"版本使用,参考博客

import (
	"fmt"
	"github.com/zeromicro/go-zero/core/stringx"
	"github.com/zeromicro/go-zero/core/syncx"
	"sync"
	"time"
)

syncx.NewSingleFlight()

以NewSharedCalls()为例解释底层

NewSharedCalls()是老版本的, go-zero中针对该功能提供了一个SharedCalls接口,内部有Do和DoEx两种方法的抽象

// SharedCalls接口提供了Do和DoEx两种方法
type SharedCalls interface {
  Do(key string, fn func() (interface{}, error)) (interface{}, error)
  DoEx(key string, fn func() (interface{}, error)) (interface{}, bool, error)
}

在调用NewSharedCalls()时会返回sharedGroup实现

// call代表对指定资源的一次请求
type call struct {
  wg  sync.WaitGroup  // 用于协调各个请求goroutine之间的资源共享
  val interface{}     // 用于保存请求的返回值
  err error           // 用于保存请求过程中发生的错误
}
type sharedGroup struct {
  calls map[string]*call
  lock  sync.Mutex
}

1. sharedGroup 下的 Do() 方法

通过Do()方法获取数据, 该方法需要两个参数:

key参数：可以理解为资源的唯一标识。
fn参数：真正获取资源的方法

// 当多个请求同时使用Do方法请求资源时
func (g *sharedGroup) Do(key string, fn func() (interface{}, error)) (interface{}, error) {
  // 先申请加锁
  g.lock.Lock()
  // 根据key，获取对应的call结果,并用变量c保存
  if c, ok := g.calls[key]; ok {
    // 拿到call以后，释放锁，此处call可能还没有实际数据，只是一个空的内存占位
    g.lock.Unlock()
    // 调用wg.Wait，判断是否有其他goroutine正在申请资源，如果阻塞，说明有其他goroutine正在获取资源
    c.wg.Wait()
    // 当wg.Wait不再阻塞，表示资源获取已经结束，可以直接返回结果
    return c.val, c.err
  }
  // 没有拿到结果，则调用makeCall方法去获取资源，注意此处仍然是锁住的，可以保证只有一个goroutine可以调用makecall
  c := g.makeCall(key, fn)
  // 返回调用结果
  return c.val, c.err
}

2. sharedGroup 下的 DoEx() 方法

和Do方法类似，只是返回值中增加了布尔值表示值是调用makeCall方法直接获取的，还是取的共享成果

func (g *sharedGroup) DoEx(key string, fn func() (interface{}, error)) (val interface{}, fresh bool, err error) {
  g.lock.Lock()
  if c, ok := g.calls[key]; ok {
    g.lock.Unlock()
    c.wg.Wait()
    return c.val, false, c.err
  }
  c := g.makeCall(key, fn)
  return c.val, true, c.err
}

3. sharedGroup 下的 makeCall() 方法

该方法由Do和DoEx方法调用，是真正发起资源请求的方法

// 进入makeCall的一定只有一个goroutine，因为要拿锁锁住的
func (g *sharedGroup) makeCall(key string, fn func() (interface{}, error)) *call {
  // 创建call结构，用于保存本次请求的结果
  c := new(call)
  // wg加1，用于通知其他请求资源的goroutine等待本次资源获取的结束
  c.wg.Add(1)
  // 将用于保存结果的call放入map中，以供其他goroutine获取
  g.calls[key] = c
  // 释放锁，这样其他请求的goroutine才能获取call的内存占位
  g.lock.Unlock()
  defer func() {
    // delete key first, done later. can't reverse the order, because if reverse,
    // another Do call might wg.Wait() without get notified with wg.Done()
    g.lock.Lock()
    delete(g.calls, key)
    g.lock.Unlock()
    // 调用wg.Done，通知其他goroutine可以返回结果，这样本批次所有请求完成结果的共享
    c.wg.Done()
  }()
  // 调用fn方法，将结果填入变量c中
  c.val, c.err = fn()
  return c
}

四. redis锁

参考博客
基础使用示例

import (
	"fmt"
	"github.com/zeromicro/go-zero/core/stores/redis"
)

func test3() {
	//1.获取redis连接
	store := redis.New("")
	//2.拼接一个key
	redisLockKey := fmt.Sprintf("%v%v", "key", "")
	//3.初始化redislock
	redisLock := redis.NewRedisLock(store, redisLockKey)
	//4.可选操作,设置 redislock 过期时间
	redisLock.SetExpire(10)
	if ok, err := redisLock.Acquire(); !ok || err != nil {
		fmt.Println("为获取到锁")
		return
	}
	defer func() {
		recover()
		// 3. 释放锁
		redisLock.Release()
	}()
}

原理相关

先看几个redis实现锁功能时底层的几个命令

ex seconds ：设置key过期时间，单位s
px milliseconds ：设置key过期时间，单位毫秒
nx：key不存在时，设置key的值
xx：key存在时，才会去设置key的值

首先会调用NewRedisLock()函数初始化redisLock

func NewRedisLock(store *Redis, key string) *RedisLock {
	return &RedisLock{
		store: store,
		key:   key,
		id:    stringx.Randn(randomLen),
	}
}

type RedisLock struct {
	store   *Redis
	seconds uint32
	key     string
	id      string
}

1. Acquire()获取锁

在获取锁时会执行一段lua脚本lockCommand

Lua 脚本保证原子性「当然，把多个操作在 Redis 中实现成一个操作，也就是单命令操作」
使用了 set key value px milliseconds nx
value 具有唯一性
加锁时首先判断 key 的 value 是否和之前设置的一致，一致则修改过期时间

const lockCommand     = `if redis.call("GET", KEYS[1]) == ARGV[1] then
    redis.call("SET", KEYS[1], ARGV[1], "PX", ARGV[2])
    return "OK"
else
    return redis.call("SET", KEYS[1], ARGV[1], "NX", "PX", ARGV[2])
end`

func (rl *RedisLock) Acquire() (bool, error) {
	return rl.AcquireCtx(context.Background())
}

func (rl *RedisLock) AcquireCtx(ctx context.Context) (bool, error) {
	seconds := atomic.LoadUint32(&rl.seconds)
	resp, err := rl.store.EvalCtx(ctx, lockCommand, []string{rl.key}, []string{
		rl.id, strconv.Itoa(int(seconds)*millisPerSecond + tolerance),
	})
	if err == red.Nil {
		return false, nil
	} else if err != nil {
		logx.Errorf("Error on acquiring lock for %s, %s", rl.key, err.Error())
		return false, err
	} else if resp == nil {
		return false, nil
	}

	reply, ok := resp.(string)
	if ok && reply == "OK" {
		return true, nil
	}

	logx.Errorf("Unknown reply when acquiring lock for %s: %v", rl.key, resp)
	return false, nil
}

2. 释放锁

会执行一段lua脚本delCommand

const delCommand = `if redis.call("GET", KEYS[1]) == ARGV[1] then
    return redis.call("DEL", KEYS[1])
else
    return 0
end`

func (rl *RedisLock) Release() (bool, error) {
	return rl.ReleaseCtx(context.Background())
}

func (rl *RedisLock) ReleaseCtx(ctx context.Context) (bool, error) {
	resp, err := rl.store.EvalCtx(ctx, delCommand, []string{rl.key}, []string{rl.id})
	if err != nil {
		return false, err
	}

	reply, ok := resp.(int64)
	if !ok {
		return false, nil
	}

	return reply == 1, nil
}

注意: 不能释放别人的锁,需要先 get(key) == value「key」,为 true 才会去 delete

五. go-zero 布隆过滤实现原理

复习布隆过滤器的相关问题

什么是布隆过滤器:

布隆过滤器可以看成一个很长的初始值都为0的,二进制数组+一系列随机hash算法映射函,类似于set的数据结构,统计结果不太准确(在统计存在时)
在添加key时: 使用多个hash函数,对key进行hash运算得到一个整数索引,然后与位数组长度进行取模运算拿到位置,每个hash函数都会得到不同的位置,将这几个位置设置为1,完成了一次add操作
查询key时,只要通过key进行hash运算拿到整数索引后与位数组长度进行取模运算,拿到位数组的位置,只要一次位数组中指定的位置值为0,就说明key不存在

解释为什么判断存在的可能不存在,假设在判断一个key是经过hash运算,与位数组长度取模运算获取到位置后判断该位置上是1,这个1可能是对别的key进行标记的
解释为什么不能删除,删除会造成误判率增加的原因: 看上图,添加obj1与obj2两个数据,假设需要通过三次hash运算获取到了三个位置obj1对应1,3,12, obj2对应3, 8, 13,会发现obj1与obj2同时都用到了3位置,假设我要删除obj1,将索引为1,3,12位置上的1设置为0,当查询obj2是否存在时走到3位置上会发现在删除obj1时已经设置为0了,实际存在的却返回不存在,发生误判
简单提一下 google在针对java时提供了一个工具包Guava,内部有对布隆过滤器的实现,BloomFilter对象,底层默认指定使用了5个hash函数,默认的误判率为0.03

go-zero 对布隆过滤器的实现

在go-zero中基于redis,基于bitmap数据类型,实现了布隆过滤器, 将数据多次hash后,插入到多个特定位并设置为1, 数据检测时经过相同hash后检测所有位,只要其中一位为0表数据不存在,否则数据可能存在, core/bloom/bloom.go
封装了一个Filter结构体

//表示经过多少散列函数计算
//固定14次
maps = 14

type (
    // 定义布隆过滤器结构体
    Filter struct {
        bits   uint
        bitSet bitSetProvider
    }
    //位数组操作接口定义
    bitSetProvider interface {
        check([]uint) (bool, error)
        set([]uint) error
    }
)

初始化方法,内部会调用newRedisBitSet()函数,返回一个redisBitSet 结构体redis位数组

func New(store *redis.Redis, key string, bits uint) *Filter {
	return &Filter{
		bits:   bits,
		bitSet: newRedisBitSet(store, key, bits),
	}
}

添加

func (f *Filter) Add(data []byte) error {
    // 获取数据多次hash后的各key
	locations := f.getLocations(data)
    // 插入数据
	return f.bitSet.set(locations)
}

判断数据是否存在

func (f *Filter) Exists(data []byte) (bool, error) {
    // 同数据set一致，获取数据多次hash后，偏移量切片
	locations := f.getLocations(data)
    // 调用check方法进行检测
	isSet, err := f.bitSet.check(locations)
	if err != nil {
		return false, err
	}
 
	return isSet, nil
}

底层

查看初始化时执行的New()函数, 内部会调用newRedisBitSet(),创建一个redisBitSet 结构体,是一个redis位数组

func newRedisBitSet(store *redis.Redis, key string, bits uint) *redisBitSet {
	return &redisBitSet{
		store: store,
		key:   key,
		bits:  bits,
	}
}

//redis位数组
type redisBitSet struct {
    store *redis.Client
    key   string
    bits  uint
}

查看添加数据与检查数据是否存在时Filter上的Add()方法与Exists方法内部首先会执行一个getLocations()方法

//k次散列计算出k个offset
func (f *Filter) getLocations(data []byte) []uint {
    //创建指定容量的切片
    locations := make([]uint, maps)
    //maps表示k值,作者定义为了常量:14
    for i := uint(0); i < maps; i++ {
        //哈希计算,使用的是"MurmurHash3"算法,并每次追加一个固定的i字节进行计算
        hashValue := hash.Hash(append(data, byte(i)))
        //取下标offset
        locations[i] = uint(hashValue % uint64(f.bits))
    }
  
    return locations
}

继续查看Filter上的Add()方法与Exists()方法,都会先获取到底层的redisBitSet变量,调用该结构体上的set()方法添加数据,调用用该结构体上的check()方法检查数据是否存在,查看redisBitSet 结构体上绑定实现的方法

//检查偏移量offset数组是否全部为1
//是:元素可能存在
//否:元素一定不存在
func (r *redisBitSet) check(offsets []uint) (bool, error) {
    args, err := r.buildOffsetArgs(offsets)
    if err != nil {
        return false, err
    }
    //执行脚本
    resp, err := r.store.Eval(testScript, []string{r.key}, args)
    //这里需要注意一下,底层使用的go-redis
    //redis.Nil表示key不存在的情况需特殊判断
    if err == redis.Nil {
        return false, nil
    } else if err != nil {
        return false, err
    }

    exists, ok := resp.(int64)
    if !ok {
        return false, nil
    }

    return exists == 1, nil
}

//将k位点全部设置为1
func (r *redisBitSet) set(offsets []uint) error {
    args, err := r.buildOffsetArgs(offsets)
    if err != nil {
        return err
    }
    _, err = r.store.Eval(setScript, []string{r.key}, args)
    //底层使用的是go-redis,redis.Nil表示操作的key不存在
    //需要针对key不存在的情况特殊判断
    if err == redis.Nil {
        return nil
    } else if err != nil {
        return err
    }
    return nil
}

//构建偏移量offset字符串数组,因为go-redis执行lua脚本时参数定义为[]stringy
//因此需要转换一下
func (r *redisBitSet) buildOffsetArgs(offsets []uint) ([]string, error) {
    var args []string
    for _, offset := range offsets {
        if offset >= r.bits {
            return nil, ErrTooLargeOffset
        }
        args = append(args, strconv.FormatUint(uint64(offset), 10))
    }
    return args, nil
}

//删除
func (r *redisBitSet) del() error {
    _, err := r.store.Del(r.key)
    return err
}

//自动过期
func (r *redisBitSet) expire(seconds int) error {
    return r.store.Expire(r.key, seconds)
}

苹果香蕉西红柿

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
go 进阶 go-zero相关: 十. redis与缓存高级

这一块代码大同小异，都是加锁，操作，再解锁的方式来进行并发管理的。通过这一块代码的阅读，基本可以明确LRU模块和命中率统计模块是如何工作的。key参数：可以理解为资源的唯一标识。fn参数：真正获取资源的方法。
复制链接

扫一扫