基本概念

缓存作为计算机领域的重要概念之一，其根本的优势在于利用空间换取时间，通过更小更快的数据存储层L1来存储访问更大更慢的数据存储层L2的数据，当需要访问L2的数据时优先在L1中寻找，在L1命中的情况下，极大地提升了访问速度。

然而在不命中的情况下，反而多了一次数据存储层L1访问，如何设计L1存储的数据才能提升命中概率？由程序访问的时间及空间局部性原理可知，程序更倾向于访问最近访问过的数据及存储上相邻的数据，因此在L1中存储L2中最近访问过的数据可以提高命中概率，进而提升性能。

在计算机领域中缓存随处可见，比如：CPU寄存器（作为CPU高速缓存的缓存）、CPU高速缓存（作为内存的缓存）、内存（作为硬盘和网络资源等的缓存）和Redis数据库（通常可用作关系型数据库的缓存），其本质是节约成本（更快的存储层价格更高）与提升访问速度的折中。

内存缓存仅适用于单机环境内的数据缓存，不适用于分布式共享数据的应用。GO常见的内存缓存包之一为https://github.com/patrickmn/go-cache，其中的cache.go文件中定义了内存缓存。

Cache结构

首先定义了cache的存储结构，由此可以看到：

1. defaultExpiration是当前缓存中所有数据的默认过期时间；
2. items是存储缓存数据的是映射，其中每一个元素是Key-Value结构且附带了一个Expiration过期时间；当Expiration=-1时，永不过期；
3. mu是一个读写锁（允许同时读，但一个写与其他读写互斥），尽可能地在并发安全的情况下提升读取缓存数据的性能；
4. onEvicted是当Key-Value到期淘汰时触发的回调函数；
5. janitor清洁工，定期地扫描缓存中过期的数据（根据Expiration）。

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

New方法

Cache的创建方法为New方法，其中第一个参数defaultExpiration为元素的默认过期时间，第二个参数cleanupInterval为定时清理的时间间隔，在实例化items后调用newCacheWithJanitor生成cache实例，如果cleanupInterval>0，启动定时清理janitor并设置janitor的结束时机在cache的垃圾回收时。

func New(defaultExpiration, cleanupInterval time.Duration) *Cache {
	items := make(map[string]Item)
	return newCacheWithJanitor(defaultExpiration, cleanupInterval, items)
}

func newCache(de time.Duration, m map[string]Item) *cache {
	if de == 0 {
		de = -1
	}
	c := &cache{
		defaultExpiration: de,
		items:             m,
	}
	return c
}

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)
		runtime.SetFinalizer(C, stopJanitor)
	}
	return C
}

OnEvicted方法

OnEvicted方法是为cache设置删除回调函数的唯一方法，由于onEvicted伴随删除缓存方法而使用，因此必须加写锁（互斥锁），避免并发冲突。

func (c *cache) OnEvicted(f func(string, interface{})) {
	c.mu.Lock()
	c.onEvicted = f
	c.mu.Unlock()
}

Set与Add方法

Set方法：当传入的过期时间间隔d为0时，则改为cache的默认过期时间，如果d>0，则e为当前时间加上d即为过期时间（用于后续清理时与时间进行比较）。在加上写锁（互斥锁）的情况下增加了一个item或者修改了一个item。

Add方法与Set方法的区别在于首先判断item是否存在，如果已经存在，直接返回error。

可以注意到，cache中所有方法都没有使用defer，作者认为defer带来的延迟影响对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()
	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方法

Get方法只是读取数据，因此在锁方面只需要使用读锁（共享锁），首先判断item是否存在，即使在存在的情况下，也要进一步根据expiration与当前时间进行比较（因为清理是定时的，可能存在一些过期但没有清理的item），只有没过期的item才能返回数据。

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
}

DeleteExpire方法

K-V结构体定义

type keyAndValue struct {
	key   string
	value interface{}
}

DeleteExpire方法检查并删除items中过期的item，需要使用写锁。根据此处的过期时间比较可知，如果expiration<=0则永不过期。

func (c *cache) DeleteExpired() {
	var evictedItems []keyAndValue
	now := time.Now().UnixNano()
	c.mu.Lock()
	for k, v := range c.items {
		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)
	}
}

Janitor定时清理器

Janitor结构体由字段Interval（清理时间间隔）和stop（停止定时清理）组成，stop为非缓存的bool通道。

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

runJanitor方法首先创建cache的janitor实例，通过协程开启定时任务Run方法，其中当stop通道没有接收到值时，则定时执行DeleteExpire方法清理过期数据；当stop通道接收到值，则退出。

stop方法向通道发送值，控制定时清理结束。

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
}

持久化方法

此外，由于DRAM内存的易失性（断电数据丢失），因此cache也为使用者提供了持久化方法和加载方法，涉及的为Save(w io.Writer)、SaveFile(fname string)、Load(r io.Reader)、LoadFile(fname string)。