Go 缓存系列之 go-cache

 go

版权

我是一只可爱的土拨鼠，专注于分享 Go 职场、招聘和求职，解 Gopher 之忧！欢迎关注我。

欢迎大家加入Go招聘交流群，来这里找志同道合的小伙伴！跟土拨鼠们一起交流学习。

一句话描述

go-cache [1]基于内存的 K/V 存储/缓存 : (类似于Memcached)，适用于单机应用程序

简介

go-cache是什么？

基于内存的 K/V 存储/缓存 : (类似于Memcached)，适用于单机应用程序 ，支持删除，过期，默认Cache共享锁，

大量key的情况下会造成锁竞争严重

为什么选择go-cache？

可以存储任何对象（在给定的持续时间内或永久存储），并且可以由多个goroutine安全地使用缓存。

Example

1. package main

3. import (

4.  "fmt"

5.  "time"

7.  "github.com/patrickmn/go-cache"

8. )

10. type MyStruct struct {

11.  Name string

12. }

14. func main() {

15.  // 设置超时时间和清理时间

16.  c := cache.New(5*time.Minute, 10*time.Minute)

18.  // 设置缓存值并带上过期时间

19.  c.Set("foo", "bar", cache.DefaultExpiration)

22.  // 设置没有过期时间的KEY，这个KEY不会被自动清除，想清除使用：c.Delete("baz")

23.  c.Set("baz", 42, cache.NoExpiration)

26.  var foo interface{}

27.  var found bool

28.  // 获取值

29.  foo, found = c.Get("foo")

30.  if found {

31.   fmt.Println(foo)

32.  }

34.  var foos string

35.  // 获取值， 并断言

36.  if x, found := c.Get("foo"); found {

37.   foos = x.(string)

38.   fmt.Println(foos)

39.  }

40.  // 对结构体指针进行操作

41.  var my *MyStruct

42.  c.Set("foo", &MyStruct{Name: "NameName"}, cache.DefaultExpiration)

43.  if x, found := c.Get("foo"); found {

44.   my = x.(*MyStruct)

45.   // ...

46.  }

47.  fmt.Println(my)

48. }

源码分析

源码分析主要针对核心的存储结构、Set、Get、Delete、定时清理逻辑进行分析。包含整体的逻辑架构

核心的存储结构

1. package cache

3. // Item 每一个具体缓存值

4. type Item struct {

5.  Object     interface{}

6.  Expiration int64 // 过期时间:设置时间+缓存时长

7. }

9. // Cache 整体缓存

10. type Cache struct {

11.  *cache

12. }

14. // cache 整体缓存

15. type cache struct {

16.  defaultExpiration time.Duration // 默认超时时间

17.  items             map[string]Item // KV对

18.  mu                sync.RWMutex // 读写锁，在操作（增加，删除）缓存时使用

19.  onEvicted         func(string, interface{}) // 删除KEY时的CallBack函数

20.  janitor           *janitor // 定时清空缓存的结构

21. }

23. // janitor  定时清空缓存的结构

24. type janitor struct {

25.  Interval time.Duration // 多长时间扫描一次缓存

26.  stop     chan bool // 是否需要停止

27. }

Set

1. package cache

2. func (c *cache) Set(k string, x interface{}, d time.Duration) {

3.  // "Inlining" of set

4.  var e int64

5.  if d == DefaultExpiration {

6.   d = c.defaultExpiration

7.  }

8.  if d > 0 {

9.   e = time.Now().Add(d).UnixNano()

10.  }

11.  c.mu.Lock() // 这里可以使用defer？

12.  c.items[k] = Item{

13.   Object:     x, // 实际的数据

14.   Expiration: e, // 下次过期时间

15.  }

16.  c.mu.Unlock()

17. }

Get

1. package cache

2. func (c *cache) Get(k string) (interface{}, bool) {

3.  c.mu.RLock() // 加锁，限制并发读写

4.  item, found := c.items[k] // 在 items 这个 map[string]Item 查找数据

5.  if !found {

6.   c.mu.RUnlock()

7.   return nil, false

8.  }

9.  if item.Expiration > 0 {

10.   if time.Now().UnixNano() > item.Expiration { // 已经过期，直接返回nil，为什么在这里不直接就删除了呢？

11.    c.mu.RUnlock()

12.    return nil, false

13.   }

14.  }

15.  c.mu.RUnlock()

16.  return item.Object, true

17. }

Delete

1. package cache

2. // Delete an item from the cache. Does nothing if the key is not in the cache.

3. func (c *cache) Delete(k string) {

4.  c.mu.Lock()

5.  v, evicted := c.delete(k)

6.  c.mu.Unlock()

7.  if evicted {

8.   c.onEvicted(k, v) // 删除KEY时的CallBack

9.  }

10. }

12. func (c *cache) delete(k string) (interface{}, bool) {

13.  if c.onEvicted != nil {

14.   if v, found := c.items[k]; found {

15.    delete(c.items, k)

16.    return v.Object, true

17.   }

18.  }

19.  delete(c.items, k)

20.  return nil, false

21. }

定时清理逻辑

1. package cache

2. func newCacheWithJanitor(de time.Duration, ci time.Duration, m map[string]Item) *Cache {

3.  c := newCache(de, m)

4.  C := &Cache{c}

5.  if ci > 0 {

6.   runJanitor(c, ci) // 定时运行清除过期KEY

7.   runtime.SetFinalizer(C, stopJanitor) // 当C被GC回收时，会停止runJanitor 中的协程

8.  }

9.  return C

10. }

12. func runJanitor(c *cache, ci time.Duration) {

13.  j := &janitor{

14.   Interval: ci,

15.   stop:     make(chan bool),

16.  }

17.  c.janitor = j

18.  go j.Run(c) // 新的协程做过期删除逻辑

19. }

21. func (j *janitor) Run(c *cache) {

22.  ticker := time.NewTicker(j.Interval)

23.  for {

24.   select {

25.   case <-ticker.C: // 每到一个周期就全部遍历一次

26.    c.DeleteExpired() // 实际的删除逻辑

27.   case <-j.stop:

28.    ticker.Stop()

29.    return

30.   }

31.  }

32. }

34. // Delete all expired items from the cache.

35. func (c *cache) DeleteExpired() {

36.  var evictedItems []keyAndValue

37.  now := time.Now().UnixNano()

38.  c.mu.Lock()

39.  for k, v := range c.items { // 加锁遍历整个列表

40.   // "Inlining" of expired

41.   if v.Expiration > 0 && now > v.Expiration {

42.    ov, evicted := c.delete(k)

43.    if evicted {

44.     evictedItems = append(evictedItems, keyAndValue{k, ov})

45.    }

46.   }

47.  }

48.  c.mu.Unlock()

49.  for _, v := range evictedItems {

50.   c.onEvicted(v.key, v.value)

51.  }

52. }

思考

Lock 的使用

• 在go-cache中，涉及到读写cache，基本上都用到了锁，而且在遍历的时候也用到锁，当cache的数量非常多时，读写频繁时， 会有严重的锁冲突。

使用读写锁？

• sync.RWMutex, 在读的时候加RLock, 可以允许多个读。在写的时候加Lock，不允许其他读和写。

锁的粒度是否可以变更小？

• 根据KEY HASH 到不同的map中

使用sync.map?

• 减少锁的使用

runtime.SetFinalizer

在实际的编程中，我们都希望每个对象释放时执行一个方法，在该方法内执行一些计数、释放或特定的要求， 以往都是在对象指针置nil前调用一个特定的方法， golang提供了runtime.SetFinalizer函数，当GC准备释放对象时，会回调该函数指定的方法，非常方便和有效。

对象可以关联一个SetFinalizer函数， 当gc检测到unreachable对象有关联的SetFinalizer函数时， 会执行关联的SetFinalizer函数， 同时取消关联。这样当下一次gc的时候， 对象重新处于unreachable状态 并且没有SetFinalizer关联， 就会被回收。

Doc

https://pkg.go.dev/github.com/patrickmn/go-cache

比较

相似的库

• https://github.com/golang/groupcache

• https://github.com/allegro/bigcache

• https://github.com/coocood/freecache

参考资料

[1] 

go-cache : https://github.com/patrickmn/go-cache

---

资料分享，公众号后台回复暗号即可获取

• 【100】Go资深工程师简历模板

• 【101 】Go全网最全的面试集锦

• 【102】Go超级简历

---

推荐阅读

• 祝大家5.1快乐，4/26-4/30股文请接收

• 国际电商福利好还不加班，爱了爱了

• 一手资源在手，说Go就Go

---

欢迎关注我！获取更多招聘相关信息。