go key-value缓存go-cache实现

 

Cache类型

Cache封装了一个cache类型，cache类型的参数解析：

1.defaultExpiration time.Duration

每个键值的默认过期时间。

2.items map[string]Item

map类型。

3.mu sync.RWMutex

map类型的读写锁。

4.janitor *janitor

监控map中键值是否过期，定期删除map中过期的键值。

5.onEvicted func(string, interface{})

用户定义，可以对已经被删除键值做二次操作。

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
	onEvicted         func(string, interface{})
	janitor           *janitor
}

Item类型如下，定义map中key对应的每个值：

type Item struct {
	Object     interface{}
	Expiration int64
//一个参数是Object存储value，另一个参数Expiration 为过期时间。
}

初始化Cache

New(defaultExpiration, cleanupInterval time.Duration) *Cache {}：返回*Cache类型。

	//创建一个缓存库，这个缓存库默认每个键值的过期时间为五分钟，每十分钟清理一次
	c := cache.New(5*time.Minute, 10*time.Minute)

newCacheWithJanitor(de time.Duration, ci time.Duration, m map[string]Item) *Cache{}：先创建map，继续往下调用。

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 {
	//de为每个键值对的默认过期时间，ci为缓存池的定期扫描时间，m为缓存map：make(map[string]Item)
　　　　 //初始化cache
	c := newCache(de, m)
　　　　 //初始化Cache
	C := &Cache{c}
	if ci > 0 {
		//监控map：创建监控器及定时器
		runJanitor(c, ci)
		//给C绑定方法,当垃圾回收的时候执行
		runtime.SetFinalizer(C, stopJanitor)
	}
	return C
}

newCache(de time.Duration, m map[string]Item) *cache ：初始化cache：可以这里定义cache的属性。

func newCache(de time.Duration, m map[string]Item) *cache {
	if de == 0 {
		de = -1
	}
	c := &cache{
		defaultExpiration: de,
		items:             m,
		onEvicted: func(s string, i interface{}) {
			println("键值被删除了，可以做这里做二次操做")
		},
	}
	return c
}

监控器及定时器

监控器有两个属性，一个是定时扫描是否过期的时间，第二个为通知监控器关闭的信道。

type janitor struct {
	Interval time.Duration
	stop     chan bool
}

创建监控器及使用协程启动。

func runJanitor(c *cache, ci time.Duration) {
	j := &janitor{
		Interval: ci,
		stop:     make(chan bool),
	}
	c.janitor = j
	go j.Run(c)
}

运行监控器，创建了一个定时器，使用select监控定时器信道和关闭信道。

func (j *janitor) Run(c *cache) {
	//创建定时器
	ticker := time.NewTicker(j.Interval)
	for {
		select {
		case <-ticker.C://当定时器每次到达设置的时间时就会向管道发送消息，此时检查map中的键值是否过期
			c.DeleteExpired()
		case <-j.stop: //监视器退出信道，
			ticker.Stop()
			return
		}
	}
}

添加记录

c.Set("foo", "bar", cache.DefaultExpiration)

const (
	NoExpiration time.Duration = -1
	DefaultExpiration time.Duration = 0
)

func (c *cache) Set(k string, x interface{}, d time.Duration) {
	var e int64
	if d == DefaultExpiration {
		d = c.defaultExpiration
	}
	if d > 0 {
　　　　　　　　　　//这里很重要，如果设置缓存时间大于0，则在现在时间上加上设置的缓存时间
		e = time.Now().Add(d).UnixNano()
	}
	c.mu.Lock()
	c.items[k] = Item{
		Object:     x,
		Expiration: e,
	}
	c.mu.Unlock()
}

删除记录

c.Delete("foo")

func (c *cache) Delete(k string) {
	c.mu.Lock()
　　　　　//如果有OnEvicted方法，则返回k及true，如果没有，则返回空和false
	v, evicted := c.delete(k)
	c.mu.Unlock()
　　　　　//evivted为真，则表示用户自定义了OnEvicted方法，对删的键值做删除后的操作
	if evicted {
		c.onEvicted(k, v)
	}
}

func (c *cache) delete(k string) (interface{}, bool) {
	if c.onEvicted != nil {
		//如果存在OnEvicted方法，则执行，
		if v, found := c.items[k]; found {
			delete(c.items, k)
			return v.Object, true
		}
	}
　　　　//如果不存在OnEvicted方法
	delete(c.items, k)
	return nil, false
}

定期删除

// Delete all expired items from the cache.
func (c *cache) DeleteExpired() {
	var evictedItems []keyAndValue
	//现在时间戳
	now := time.Now().UnixNano()
	//map加互斥锁
	c.mu.Lock()
	for k, v := range c.items {
		// "Inlining" of expired
		//检测map
		if v.Expiration > 0 && now > v.Expiration {
			//超时则删除
			ov, evicted := c.delete(k)
			//err为真则会记录删除的键值，也表示onEvicted方法存在，对删除的key-value做二次操作
			if evicted {
				evictedItems = append(evictedItems, keyAndValue{k, ov})
			}
		}
	}
	c.mu.Unlock()//解互斥锁
	//c.onEvicted为函数类型，初始缓存map的时候赋值：func(string, interface{})
	//替换这个函数：func (c *cache) OnEvicted(f func(string, interface{}))
	//可以对已经删除的key—value做二次操作，用户定义
	for _, v := range evictedItems {
		c.onEvicted(v.key, v.value)
	}
}

go实现定时器模板：定时循环执行

package main

import "time"

type janitor struct {
	Interval time.Duration
	stop     chan bool
}

func (j *janitor) Run() {
	//创建定时器
	ticker := time.NewTicker(j.Interval)
	for {
		select {
		case <-ticker.C://当定时器每次到达设置的时间时就会向管道发送消息，此时检查map中的键值是否过期
			print("开始扫描\n")
		case <-j.stop: //监视器退出信道，
			ticker.Stop()
			close(j.stop)
			return
		}
	}
}

func stopJanitor(j *janitor) {
	j.stop <- true
}

func runJanitor(ci time.Duration) {
	j := &janitor{
		Interval: ci,
		stop:     make(chan bool),
	}
	go j.Run()
}


func main(){
	runJanitor(time.Second)
	select {

	}
}