当前位置：网站首页>Go cache of go cache series

Go cache of go cache series

2022-07-02 20:55:00 【firstcode666】

go

I'm a lovely groundhog , Focus on sharing Go In the workplace 、 Recruitment and job hunting , Explain Gopher Worry about ！ Welcome to follow me .
Welcome aboard Go Recruitment exchange group , Come here to find like-minded friends ！ Communicate and learn with marmots .

One sentence description

go-cache [1] Memory based K/V Storage / cache : ( Be similar to Memcached), For stand-alone applications

brief introduction

go-cache What is it? ？

Memory based K/V Storage / cache : ( Be similar to Memcached), For stand-alone applications , Support delete , Be overdue , Default Cache Shared lock ,

A lot of key In this case, lock competition will be serious

Why choose go-cache？

Can store any object （ Store for a given duration or permanently ）, And can be composed of multiple goroutine Use cache safely .

Example

package main
import (
"fmt"
"time"
"github.com/patrickmn/go-cache"
)
type MyStruct struct {
Name string
}
func main() {
// Set timeout and cleanup time
c := cache.New(5*time.Minute, 10*time.Minute)
// Set the cache value and bring the expiration time
c.Set("foo", "bar", cache.DefaultExpiration)
// Set no expiration time KEY, This KEY Will not be automatically cleared , Want to clear use ：c.Delete("baz")
c.Set("baz", 42, cache.NoExpiration)
var foo interface{}
var found bool
// Get value
foo, found = c.Get("foo")
if found {
fmt.Println(foo)
}
var foos string
// Get value , And assert that
if x, found := c.Get("foo"); found {
foos = x.(string)
fmt.Println(foos)
}
// Operate on the structure pointer
var my *MyStruct
c.Set("foo", &MyStruct{Name: "NameName"}, cache.DefaultExpiration)
if x, found := c.Get("foo"); found {
my = x.(*MyStruct)
// ...
}
fmt.Println(my)
}

Source code analysis

Source code analysis mainly focuses on the core storage structure 、Set、Get、Delete、 Regular cleaning logic for analysis . Including the overall logical architecture

Core storage structure

package cache
// Item Each specific cache value
type Item struct {
Object interface{}
Expiration int64 // Expiration time : Setup time + Cache time
}
// Cache Overall cache
type Cache struct {
*cache
}
// cache Overall cache
type cache struct {
defaultExpiration time.Duration // Default timeout
items map[string]Item // KV Yes
mu sync.RWMutex // Read-write lock , In operation （ increase , Delete ） Cache with
onEvicted func(string, interface{}) // Delete KEY At the time of the CallBack function
janitor *janitor // Periodically clear the cache structure
}
// janitor Periodically clear the cache structure
type janitor struct {
Interval time.Duration // How often to scan the cache
stop chan bool // Whether you need to stop
}

Set

package cache
func (c *cache) Set(k string, x interface{}, d time.Duration) {
// "Inlining" of set
var e int64
if d == DefaultExpiration {
d = c.defaultExpiration
}
if d > 0 {
e = time.Now().Add(d).UnixNano()
}
c.mu.Lock() // Here you can use defer？
c.items[k] = Item{
Object: x, // The actual data
Expiration: e, // Next expiration time
}
c.mu.Unlock()
}

Get

package cache
func (c *cache) Get(k string) (interface{}, bool) {
c.mu.RLock() // Lock , Limit concurrent reads and writes
item, found := c.items[k] // stay items This map[string]Item Find data
if !found {
c.mu.RUnlock()
return nil, false
}
if item.Expiration > 0 {
if time.Now().UnixNano() > item.Expiration { // It's overdue , Go straight back to nil, Why not delete it directly here ？
c.mu.RUnlock()
return nil, false
}
}
c.mu.RUnlock()
return item.Object, true
}

Delete

package cache
// Delete an item from the cache. Does nothing if the key is not in the cache.
func (c *cache) Delete(k string) {
c.mu.Lock()
v, evicted := c.delete(k)
c.mu.Unlock()
if evicted {
c.onEvicted(k, v) // Delete KEY At the time of the CallBack
}
}
func (c *cache) delete(k string) (interface{}, bool) {
if c.onEvicted != nil {
if v, found := c.items[k]; found {
delete(c.items, k)
return v.Object, true
}
}
delete(c.items, k)
return nil, false
}

Scheduled cleanup logic

package cache
func newCacheWithJanitor(de time.Duration, ci time.Duration, m map[string]Item) *Cache {
c := newCache(de, m)
C := &Cache{c}
if ci > 0 {
runJanitor(c, ci) // Run regularly to clear expired KEY
runtime.SetFinalizer(C, stopJanitor) // When C By GC Recovery time , Will stop runJanitor Association in
}
return C
}
func runJanitor(c *cache, ci time.Duration) {
j := &janitor{
Interval: ci,
stop: make(chan bool),
}
c.janitor = j
go j.Run(c) // The new collaboration process does expiration deletion logic
}
func (j *janitor) Run(c *cache) {
ticker := time.NewTicker(j.Interval)
for {
select {
case <-ticker.C: // Every cycle is traversed once
c.DeleteExpired() // Actual deletion logic
case <-j.stop:
ticker.Stop()
return
}
}
}
// Delete all expired items from the cache.
func (c *cache) DeleteExpired() {
var evictedItems []keyAndValue
now := time.Now().UnixNano()
c.mu.Lock()
for k, v := range c.items { // Lock and traverse the whole list
// "Inlining" of expired
if v.Expiration > 0 && now > v.Expiration {
ov, evicted := c.delete(k)
if evicted {
evictedItems = append(evictedItems, keyAndValue{k, ov})
}
}
}
c.mu.Unlock()
for _, v := range evictedItems {
c.onEvicted(v.key, v.value)
}
}

reflection

Lock Use

stay go-cache in , It involves reading and writing cache, Basically, locks are used , And the lock is also used when traversing , When cache When the number is very large , When reading and writing frequently , There will be serious lock conflicts .

Use a read-write lock ？

sync.RWMutex, Add RLock, Multiple reads can be allowed . Add Lock, No other reading and writing is allowed .

Whether the granularity of locks can be changed small ？

according to KEY HASH To different map in

Use sync.map?

Reduce the use of locks

runtime.SetFinalizer

In actual programming , We all want to execute a method when each object is released , Perform some counting within this method 、 Release or specific requirements , In the past, the object pointer was set nil Before calling a specific method , golang Provides runtime.SetFinalizer function , When GC When preparing to release objects , The method specified by this function will be called back , Very convenient and effective .

Object can be associated with a SetFinalizer function , When gc detected unreachable Object has an associated SetFinalizer Function time , Will execute the associated SetFinalizer function , At the same time, cancel the Association . So next time gc When , The object is back in unreachable state And there's no SetFinalizer relation , It will be recycled .