groupcache 简介
在软件系统中使用缓存,可以降低系统响应时间,提高用户体验,降低某些系统模块的压力.
groupcache是一款开源的缓存组件.与memcache与redis不同的时,groupcache不需要单独的部署,可以作为你程序的一个库来使用. 这样方便我们开发的程序部署.
本篇主要解析groupcache源码中的关键部分， lru的定义以及如何做到同一个key只加载一次。
缓存填充以及加载抑制的实现
上篇有提到load函数的实现， 缓存填充的逻辑也体现在这里。
groupcache尽量避免从源中获取数据，当本地数据缺失时会先从peer中获取，peer中命中则直接填充到本地，未命中才会从源中加载，这正是缓存填充的实现逻辑。
而加载抑制，避免重复加载的功能是依靠 singleflight包实现的。
这个包中主要有两个结构体：
call用来存放获取结果（val）和错误(err), 每个key对应一个call实例。wg用来控制请求的等待。
|
1
2
3
4
5
|
type call struct {
wg sync.WaitGroup
val interface{}
err error
}
|
Group用来存放所有的call,记录所有的请求。
|
1
2
3
4
|
type Group struct {
mu sync.Mutex // protects m
m map[string]*call // lazily initialized
}
|
Group.Do是功能的实现。
当接到一个请求时， 会首先加锁, 并初始化用来记录请求的map。map的键为请求的key, 值为call
|
1
2
3
4
|
g.mu.Lock()
if g.m == nil {
g.m = make(map[string]*call)
}
|
如果当前的key已经在请求加载的过程中，那么解除上一步定义的冲突锁，并等待已经存在的加载请求结束后返回。
|
1
2
3
4
5
|
if c, ok := g.m[key]; ok {
g.mu.Unlock()
c.wg.Wait()
return c.val, c.err
}
|
如果当前的key没有已经存在的加载过程，那么创建一个call实例, 加入到map记录中，并向call.wg中加入一个记录，以阻塞其他请求，解除上一步定义的冲突锁。
|
1
2
3
4
|
c := new(call)
c.wg.Add(1)
g.m[key] = c
g.mu.Unlock()
|
调用传入的函数（作者并没有将这个功能局限于数据获取，通过传入的func可以实现不同功能的控制）,将结果赋值给call,获取完成后wg.done结束阻塞。
|
1
2
|
c.val, c.err = fn()
c.wg.Done()
|
然后删除map记录
|
1
2
3
|
g.mu.Lock()
delete(g.m, key)
g.mu.Unlock()
|
这个功能的实现主要是依靠sync.WaitGroup的阻塞实现， 这里也是对初学者最难理解的地方。
可以想象一个场景：
大学寝室中，你和你的室友都要到食堂买午饭，你对室友说：“你自己去就行，给我带一份”。然后你就在宿舍中等待舍友回来。
在这个场景中，你和室友就是请求，你在等待就是阻塞。
cache(lru)
上篇提到的主缓存和热缓存均是依靠cache实现。
cache的实现依靠双向链表。MaxEntries 最大的存储量OnEvicted当发生驱逐时（即到达MaxEntries）执行的操作ll双向链表本体cache key对应链表中的元素
|
1
2
3
4
5
6
7
8
9
10
11
12
|
type Cache struct {
// MaxEntries is the maximum number of cache entries before
// an item is evicted. Zero means no limit.
MaxEntries int
// OnEvicted optionally specifies a callback function to be
// executed when an entry is purged from the cache.
OnEvicted func(key Key, value interface{})
ll *list.List
cache map[interface{}]*list.Element
}
|
添加时会先进行初始化map，如果key已存在，那么会将key的index提到首位（这里的链表不存在index，仅为方便理解），并更新其value。
如果不存在则直接插入到首位。
如果插入后的长度超过限制， 会执行清理操作
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
func (c *Cache) Add(key Key, value interface{}) {
if c.cache == nil {
c.cache = make(map[interface{}]*list.Element)
c.ll = list.New()
}
if ee, ok := c.cache[key]; ok {
c.ll.MoveToFront(ee)
ee.Value.(*entry).value = value
return
}
ele := c.ll.PushFront(&entry{key, value})
c.cache[key] = ele
if c.MaxEntries != 0 && c.ll.Len() > c.MaxEntries {
c.RemoveOldest()
}
}
|
清理时会删除尾部元素， 这里就解释了为什么每次操作时会把元素提到首位。
|
1
2
3
4
5
6
7
8
9
|
func (c *Cache) RemoveOldest() {
if c.cache == nil {
return
}
ele := c.ll.Back()
if ele != nil {
c.removeElement(ele)
}
}
|
以上就是golang中cache组件的使用之groupcache的详细内容，更多关于go groupcache用法的资料请关注服务器之家其它相关文章！
原文链接：https://blog.csdn.net/q1403539144/article/details/117732190