golang中cache組件的使用及groupcache源碼解析

groupcache 簡介

在軟件系統(tǒng)中使用緩存,可以降低系統(tǒng)響應(yīng)時間,提高用戶體驗,降低某些系統(tǒng)模塊的壓力.
groupcache是一款開源的緩存組件.與memcache與redis不同的時,groupcache不需要單獨的部署,可以作為你程序的一個庫來使用. 這樣方便我們開發(fā)的程序部署.

本篇主要解析groupcache源碼中的關(guān)鍵部分， lru的定義以及如何做到同一個key只加載一次。

緩存填充以及加載抑制的實現(xiàn)

上篇有提到load函數(shù)的實現(xiàn)， 緩存填充的邏輯也體現(xiàn)在這里。
groupcache盡量避免從源中獲取數(shù)據(jù)，當本地數(shù)據(jù)缺失時會先從peer中獲取，peer中命中則直接填充到本地，未命中才會從源中加載，這正是緩存填充的實現(xiàn)邏輯。
而加載抑制，避免重復(fù)加載的功能是依靠 singleflight包實現(xiàn)的。
這個包中主要有兩個結(jié)構(gòu)體：

call用來存放獲取結(jié)果（val）和錯誤(err), 每個key對應(yīng)一個call實例。wg用來控制請求的等待。

type call struct {
	wg  sync.WaitGroup
	val interface{}
	err error
}

Group用來存放所有的call,記錄所有的請求。

type Group struct {
	mu sync.Mutex       // protects m
	m  map[string]*call // lazily initialized
}

Group.Do是功能的實現(xiàn)。
當接到一個請求時， 會首先加鎖, 并初始化用來記錄請求的map。map的鍵為請求的key, 值為call

g.mu.Lock()
if g.m == nil {
	g.m = make(map[string]*call)
}

如果當前的key已經(jīng)在請求加載的過程中，那么解除上一步定義的沖突鎖，并等待已經(jīng)存在的加載請求結(jié)束后返回。

if c, ok := g.m[key]; ok {
	g.mu.Unlock()
	c.wg.Wait()
	return c.val, c.err
}

如果當前的key沒有已經(jīng)存在的加載過程，那么創(chuàng)建一個call實例, 加入到map記錄中，并向call.wg中加入一個記錄，以阻塞其他請求，解除上一步定義的沖突鎖。

c := new(call)
c.wg.Add(1)
g.m[key] = c
g.mu.Unlock()

調(diào)用傳入的函數(shù)（作者并沒有將這個功能局限于數(shù)據(jù)獲取，通過傳入的func可以實現(xiàn)不同功能的控制）,將結(jié)果賦值給call,獲取完成后wg.done結(jié)束阻塞。

c.val, c.err = fn()
c.wg.Done()

然后刪除map記錄

g.mu.Lock()
delete(g.m, key)
g.mu.Unlock()

這個功能的實現(xiàn)主要是依靠sync.WaitGroup的阻塞實現(xiàn)， 這里也是對初學(xué)者最難理解的地方。
可以想象一個場景：
大學(xué)寢室中，你和你的室友都要到食堂買午飯，你對室友說：“你自己去就行，給我?guī)б环荨?。然后你就在宿舍中等待舍友回來?br /> 在這個場景中，你和室友就是請求，你在等待就是阻塞。

cache(lru)

上篇提到的主緩存和熱緩存均是依靠cache實現(xiàn)。
cache的實現(xiàn)依靠雙向鏈表。
MaxEntries 最大的存儲量
OnEvicted當發(fā)生驅(qū)逐時（即到達MaxEntries）執(zhí)行的操作
ll雙向鏈表本體
cache key對應(yīng)鏈表中的元素

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。
如果不存在則直接插入到首位。
如果插入后的長度超過限制， 會執(zhí)行清理操作

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()
	}
}

清理時會刪除尾部元素， 這里就解釋了為什么每次操作時會把元素提到首位。

func (c *Cache) RemoveOldest() {
	if c.cache == nil {
		return
	}
	ele := c.ll.Back()
	if ele != nil {
		c.removeElement(ele)
	}
}

以上就是golang中cache組件的使用之groupcache的詳細內(nèi)容，更多關(guān)于go groupcache用法的資料請關(guān)注腳本之家其它相關(guān)文章！