一句话概括
基于内存的KV缓存，支持删除和过期以及持久化到文件并恢复。
使用示例
go.mod增加依赖
require github.com/patrickmn/go-cache v2.1.0+incompatible
package main
import (
"log"
"time"
"github.com/patrickmn/go-cache"
)
var c *cache.Cache
func init() {
// new 一个cache，设置默认过期时间5s和清理周期2s
c = cache.New(5*time.Second, 2*time.Second)
log.Println("init cache success")
}
func getByKey() {
if value, ok := c.Get("abc"); ok {
log.Println("has abc:", value)
} else {
log.Println("no abc")
}
}
func main() {
log.Println("use cache")
getByKey()
log.Println("set abc value")
c.Set("abc", "def", cache.DefaultExpiration)
getByKey()
log.Println("sleep 6s")
time.Sleep(6 * time.Second)
getByKey()
}运行结果
2022/09/10 10:12:14 init cache success
2022/09/10 10:12:14 use cache
2022/09/10 10:12:14 no abc
2022/09/10 10:12:14 set abc value
2022/09/10 10:12:14 has abc: def
2022/09/10 10:12:14 sleep 6s
2022/09/10 10:12:20 no abc源码分析
存储结构
type Item struct {
// value
Object interface{}
// 添加key时间+过期时间
Expiration int64
}
type Cache struct {
*cache
// If this is confusing, see the comment at the bottom of New()
}
type cache struct {
defaultExpiration time.Duration
items map[string]Item
// 读写锁
mu sync.RWMutex
// 删除key时的回调函数
onEvicted func(string, interface{})
// 定时清理过期的缓存
janitor *janitor
}
type janitor struct {
// 清理过期缓存的时间间隔
Interval time.Duration
// 是否停止清理
stop chan bool
}操作逻辑
func New(defaultExpiration, cleanupInterval time.Duration) *Cache {
items := make(map[string]Item)
return newCacheWithJanitor(defaultExpiration, cleanupInterval, items)
}
func newCacheWithJanitor(de time.Duration, ci time.Duration, m map[string]Item) *Cache {
c := newCache(de, m)
// This trick ensures that the janitor goroutine (which--granted it
// was enabled--is running DeleteExpired on c forever) does not keep
// the returned C object from being garbage collected. When it is
// garbage collected, the finalizer stops the janitor goroutine, after
// which c can be collected.
// 重点
// 因为回收cache时停止定时清理协程，确保下次回收cache时不会被定时清理协程阻止，所以包了一层
C := &Cache{c}
if ci > 0 {
runJanitor(c, ci)
// C被GC回收时停止runJanitor中的协程
runtime.SetFinalizer(C, stopJanitor)
}
return C
}
func newCache(de time.Duration, m map[string]Item) *cache {
if de == 0 {
de = -1
}
c := &cache{
defaultExpiration: de,
items: m,
}
return c
}go对象可以通过SetFinalizer关联回调函数，当gc检测到unreachable对象有回调函数时，执行回调函数后取消关联。下一次gc时回收该对象。
func runJanitor(c *cache, ci time.Duration) {
j := &janitor{
Interval: ci,
stop: make(chan bool),
}
c.janitor = j
go j.Run(c)
}
func (j *janitor) Run(c *cache) {
ticker := time.NewTicker(j.Interval)
for {
select {
case <-ticker.C:
c.DeleteExpired()
case <-j.stop:
ticker.Stop()
return
}
}
}
func stopJanitor(c *Cache) {
c.janitor.stop <- true
}
func (c *cache) DeleteExpired() {
var evictedItems []keyAndValue
now := time.Now().UnixNano()
c.mu.Lock()
for k, v := range c.items {
// "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)
}
}
// Add an item to the cache, replacing any existing item. If the duration is 0
// (DefaultExpiration), the cache's default expiration time is used. If it is -1
// (NoExpiration), the item never expires.
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()
c.items[k] = Item{
Object: x,
Expiration: e,
}
// TODO: Calls to mu.Unlock are currently not deferred because defer
// adds ~200 ns (as of go1.)
c.mu.Unlock()
}
// Get an item from the cache. Returns the item or nil, and a bool indicating
// whether the key was found.
func (c *cache) Get(k string) (interface{}, bool) {
c.mu.RLock()
// "Inlining" of get and Expired
item, found := c.items[k]
if !found {
c.mu.RUnlock()
return nil, false
}
if item.Expiration > 0 {
if time.Now().UnixNano() > item.Expiration {
c.mu.RUnlock()
return nil, false
}
}
c.mu.RUnlock()
return item.Object, true
}
// 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)
}
}
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
}标签：10,cache,mu,item,patrickmn,gocache,func,time From： https://www.cnblogs.com/WJQ2017/p/17555694.html