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

Posted on by

groupcache 簡介

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

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

緩存填充以及加載抑制的實現

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

call用來存放獲取結果（val）和錯誤(err), 每個key對應一個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是功能的實現。
當接到一個請求時， 會首先加鎖, 並初始化用來記錄請求的map。map的鍵為請求的key, 值為call

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

如果當前的key已經在請求加載的過程中，那麼解除上一步定義的沖突鎖，並等待已經存在的加載請求結束後返回。

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

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

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

調用傳入的函數（作者並沒有將這個功能局限於數據獲取，通過傳入的func可以實現不同功能的控制）,將結果賦值給call,獲取完成後wg.done結束阻塞。

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

然後刪除map記錄

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

這個功能的實現主要是依靠sync.WaitGroup的阻塞實現， 這裡也是對初學者最難理解的地方。
可以想象一個場景：
大學寢室中，你和你的室友都要到食堂買午飯，你對室友說：“你自己去就行，給我帶一份”。然後你就在宿舍中等待舍友回來。
在這個場景中，你和室友就是請求，你在等待就是阻塞。

cache(lru)

上篇提到的主緩存和熱緩存均是依靠cache實現。
cache的實現依靠雙向鏈表。
MaxEntries 最大的存儲量
OnEvicted當發生驅逐時（即到達MaxEntries）執行的操作
ll雙向鏈表本體
cache key對應鏈表中的元素

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

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的詳細內容，更多關於go groupcache用法的資料請關註WalkonNet其它相關文章！

推薦閱讀：