cachetable分析

原文地址：https://www.cnblogs.com/cloudgeek/p/9201316.htm

 

今天我们来看cachetable.go这个源码文件，除了前面介绍过的主要数据结构CacheTable外还有如下2个类型：

下面先看剩下2个类型是怎么定义的：

CacheItemPair非常简单，注释一句话讲的很清楚，是用来映射key到访问计数的

　　CacheItemPairList明显就是一个CacheItemPair组成的“列表”，在go中对应的就是切片，绑定到CacheItemPairList类型的方法有3个，Swap和Len太直观了，不再赘述，Less方法判断CacheItemPairList中的第i个CacheItemPair和第j个CacheItemPair的AccessCount大小关系，前者大则返回true，反之false。逻辑是这样，用处我们在后面具体看(和自定义排序相关，后面我们会讲到这里的玄机)。

• CacheTable类型绑定的方法

这个源码文件中除了上面讲到的部分外就只剩下CacheTable类型绑定的方法了，先看一下有多少：

 下面一个个来看吧~

 1.

Count()方法返回的是指定CacheTable中的item条目数，这里的table.items是一个map类型，len函数返回map中元素数量

 2.

Foreach方法接收一个函数参数，方法内遍历了items，把每个key和value都丢给了trans函数来处理，trans函数的参数列表是key interface{}, item *CacheItem，分别对应任意类型的key和CacheItem类型的缓存条目的引用。

3.

　　先看一下参数列表：f func(interface{}, ...interface{}) *CacheItem

　　形参的意思是：形参名：f，形参类型：func(interface{}, ...interface{}) *CacheItem

　　形参类型是一个函数类型，这个函数的参数是一个key和不定数目的argument，返回值是CacheItem指针。

　　然后在SetDataLoader中将这个函数f丢给了table的loadData属性。loadData所指向的方法是什么时候被调用？注释说which will be called when trying to access a non-existing key.也就是访问一个不存在的key时会调用到。也就是说当访问一个不存在的key时，需要调用一个方法，这个方法通过SetDataLoader设定，方法的实现由用户来自定义。

4.

　　SetAddedItemCallback方法也很直观，当添加一个Item到缓存表中时会被调用的一个方法，绑定到CacheTable.addedItem上，被绑定的这个方法只接收一个参数，但是这里的参数变量名呢？为什么只写了类型*CacheItem？我去作者的github上提一个issue问问吧~开玩笑开玩笑，这里其实不需要形参变量的名字，发现没？

SetAddedItemCallback方法的形参名是f，类型是后面这个函数，也就是说func(*CacheItem)被作为一个类型，这时候假设写成func(item *CacheItem)，这里的item用得到吗？看下面这个例子就清晰了：

1func main() {
2    var show func(int)
3    show = func(num int) { fmt.Println(num) }
4    show(123)
5}

　　如上所示，定义变量show为func(int)类型的时候不需要形参变量。这个地方明白的看起来很简单，一时没有想明白的可能心中会纠结一会~

ok，也就是说SetAddedItemCallback方法设置了一个回调函数，当添加一个CacheItem的时候，同时会调用这个回调函数，这个函数可以选择对CacheItem做一些处理，比如打个日志啊什么的。

 5.

看到这里应该很轻松了，和上面的回调函数一样，这个方法是设置删除Item的时候调用的一个方法。

 6.

这个就不需要讲解了，把一个logger实例丢给table的logger属性。日志相关的知识点我会在golang专题中详细介绍。

 

7.

expirationCheck方法比较长，分析部分放在一起有点臃肿，所以我选择了源码加注释的方式来展示，每一行代码和相应的含义如下：

 1// Expiration check loop, triggered by a self-adjusting timer.
 2// 【由计时器触发的到期检查】
 3func (table *CacheTable) expirationCheck() {
 4    table.Lock()
 5    //【计时器暂停】
 6    if table.cleanupTimer != nil {
 7        table.cleanupTimer.Stop()
 8    }
 9    //【计时器的时间间隔】
10    if table.cleanupInterval > 0 {
11        table.log("Expiration check triggered after", table.cleanupInterval, "for table", table.name)
12    } else {
13        table.log("Expiration check installed for table", table.name)
14    }
15
16    // To be more accurate with timers, we would need to update 'now' on every
17    // loop iteration. Not sure it's really efficient though.
18    //【当前时间】
19    now := time.Now()
20    //【最小时间间隔，这里暂定义为0，下面代码会更新这个值】
21    smallestDuration := 0 * time.Second
22    //【遍历一个table中的items】
23    for key, item := range table.items {
24        // Cache values so we don't keep blocking the mutex.
25        item.RLock()
26        //【设置好的存活时间】
27        lifeSpan := item.lifeSpan
28        //【最后一次访问的时间】
29        accessedOn := item.accessedOn
30        item.RUnlock()
31
32        //【存活时间为0的item不作处理，也就是一直存活】
33        if lifeSpan == 0 {
34            continue
35        }
36        //【这个减法算出来的是这个item已经没有被访问的时间，如果比存活时间长，说明过期了，可以删了】
37        if now.Sub(accessedOn) >= lifeSpan {
38            // Item has excessed its lifespan.
39            //【删除操作】
40            table.deleteInternal(key)
41        } else {
42            // Find the item chronologically closest to its end-of-lifespan.
43            //【按照时间顺序找到最接近过期时间的条目】
44            //【如果最后一次访问的时间到当前时间的间隔小于smallestDuration，则更新smallestDuration】
45            if smallestDuration == 0 || lifeSpan-now.Sub(accessedOn) < smallestDuration {
46                smallestDuration = lifeSpan - now.Sub(accessedOn)
47            }
48        }
49    }
50
51    // Setup the interval for the next cleanup run.
52    //【上面已经找到了最近接过期时间的时间间隔，这里将这个时间丢给了cleanupInterval】
53    table.cleanupInterval = smallestDuration
54    //【如果是0就不科学了，除非所有条目都是0，那就不需要过期检测了】
55    if smallestDuration > 0 {
56        //【计时器设置为smallestDuration，时间到则调用func这个函数】
57        table.cleanupTimer = time.AfterFunc(smallestDuration, func() {
58            //这里并不是循环启动goroutine，启动一个新的goroutine后当前goroutine会退出，这里不会引起goroutine泄漏。
59            go table.expirationCheck()
60        })
61    }
62    table.Unlock()
63}

expirationCheck方法无非是做一个定期的数据过期检查操作，到目前为止这是项目中最复杂的一个方法，下面继续看剩下的部分。

8.

　　如上图所示，剩下的方法中划红线三个互相关联，我们放在一起看。

　　这次自上而下分析，明显Add和NotFoundAdd方法会调用addInternal方法，所以我们先看Add和NotFoundAdd方法。

先看Add()

　　注释部分说的很清楚，Add方法添加一个key/value对到cache，三个参数除了key、data、lifeSpan的含义我们在第一讲分析CacheItem类型的时候都已经介绍过。

　　NewCacheItem函数是cacheitem.go中定义的一个创建CacheItem类型实例的函数，返回值是*CacheItem类型。Add方法创建一个CacheItem类型实例后，将该实例的指针丢给了addInternal方法，然后返回了该指针。addInternal我们后面再看具体做了什么。

 9.

　　大家注意到没有，这里的注释有一个单词写错了，they key应该是the key。

　　这个方法的参数和上面的Add方法是一样一样的，含义无需多说，方法体主要分2个部分：

　　开始的if判断是检查items中是否有这个key，存在则返回false；后面的代码自然就是不存在的时候执行的，创建一个CacheItem类型的实例，然后调用addInternal添加item，最后返回true；也就是说这个函数返回true是NotFound的情况。

　　ok，下面就可以看看addInternal这个方法干了啥了。

 10.

　　这个方法无非是将CacheItem类型的实例添加到CacheTable中。方法开头的注释告诉我们调用这个方法前需要加锁，函数体前2行做了一个打日志和赋值操作，很好理解，然后将table.cleanupInterval和table.addedItem保存到局部变量，紧接着释放了锁。

　　后面的if部分调用了addedItem这个回调函数，也就是添加一个item时需要调用的函数。最后一个if判断稍微绕一点；

　　if的第一个条件：item.lifeSpan > 0，也就是当前item设置的存活时间是正数；然后&& (expDur == 0 || item.lifeSpan < expDur)，expDur保存的是table.cleanupInterval，这个值为0也就是还没有设置检查时间间隔，或者item.lifeSpan < expDur也就是设置了，但是当前新增的item的lifeSpan要更小，这个时候就触发expirationCheck执行。这里可能有点绕，要注意lifeSpan是一个item的存活时间，而cleanupInterval是对于一个table来说触发检查还剩余的时间，如果前者更小，那么就说明需要提前出发check操作了。

 11.

剩下的不多了，我们再看一组删除相关的方法

还是上面的套路，先看上层的调用者，当然就是Delete

 

　　收一个key，调用deleteInternal(key)来完成删除操作，这里实在没有啥可讲的了，我们来看deleteInternal方法是怎么写的

 12.

deleteInternal方法我也用详细注释的方式来解释吧~

 1func (table *CacheTable) deleteInternal(key interface{}) (*CacheItem, error) {
 2    r, ok := table.items[key]
 3    //【如果table中不存在key对应的item，则返回一个error】
 4    //【ErrKeyNotFound在errors.go中定义，是errors.New("Key not found in cache")】
 5    if !ok {
 6        return nil, ErrKeyNotFound
 7    }
 8
 9    // Cache value so we don't keep blocking the mutex.
10    //【将要删除的item缓存起来】
11    aboutToDeleteItem := table.aboutToDeleteItem
12    table.Unlock()
13
14    // Trigger callbacks before deleting an item from cache.
15    //【删除操作执行前调用的回调函数，这个函数是CacheTable的属性，对应下面的是aboutToExpire是CacheItem的属性】
16    if aboutToDeleteItem != nil {
17        aboutToDeleteItem(r)
18    }
19
20    r.RLock()
21    defer r.RUnlock()
22    //【这里对这条item加了一个读锁，然后执行了aboutToExpire回调函数，这个函数需要在item刚好要删除前执行】
23    if r.aboutToExpire != nil {
24        r.aboutToExpire(key)
25    }
26
27    table.Lock()
28    //【这里对表加了锁，上面已经对item加了读锁，然后这里执行delete函数删除了这个item】
29    //【delete函数是专门用来从map中删除特定key指定的元素的】
30    table.log("Deleting item with key", key, "created on", r.createdOn, "and hit", r.accessCount, "times from table", table.name)
31    delete(table.items, key)
32
33    return r, nil
34}

 13.

万里长征最后几步咯~

最后5（Not打头这个咱说过了）个方法目测不难，咱一个一个来过，先看Exists

这里我是想说：来，咱略过吧~

算了，为了教程的完整性，还是简单说一下，读锁的相关代码不需要说了，剩下的只有一行：

_, ok := table.items[key]

这里如果key存在，ok为true，反之为false，就是这样，简单吧~

 14.

Value()方法讲解，看注释吧~

 1// Value returns an item from the cache and marks it to be kept alive. You can
 2// pass additional arguments to your DataLoader callback function.
 3func (table *CacheTable) Value(key interface{}, args ...interface{}) (*CacheItem, error) {
 4    table.RLock()
 5    r, ok := table.items[key]
 6    //【loadData在load一个不存在的数据时被调用的回调函数】
 7    loadData := table.loadData
 8    table.RUnlock()
 9
10    //【如果值存在，执行下面操作】
11    if ok {
12        // Update access counter and timestamp.
13        //【更新accessedOn为当前时间】
14        r.KeepAlive()
15        return r, nil
16    }
17
18    //【这里当然就是值不存在的时候了】
19    // Item doesn't exist in cache. Try and fetch it with a data-loader.
20    if loadData != nil {
21        //【loadData这个回调函数是需要返回CacheItem类型的指针数据的】
22        item := loadData(key, args...)
23        if item != nil {
24            //【loadData返回了item的时候，万事大吉，执行Add】
25            table.Add(key, item.lifeSpan, item.data)
26            return item, nil
27        }
28        //【item没有拿到，那就只能返回nil+错误信息了】
29        //【ErrKeyNotFoundOrLoadable是执行回调函数也没有拿到data的情况对应的错误类型】
30        return nil, ErrKeyNotFoundOrLoadable
31    }
32
33    //【这个return就有点无奈了，在loadData为nil的时候执行，也就是直接返回Key找不到】
34    return nil, ErrKeyNotFound
35}

 15.

从注释可以看出来这个函数就是清空数据的作用，实现方式简单粗暴，让table的items属性指向一个新建的空map，cleanup操作对应的时间间隔设置为0，并且计时器停止。这里也可以得到cleanupInterval为0是什么场景，也就是说0不是代表清空操作死循环，间隔0秒就执行，而是表示不需要操作，缓存表还是空的。

16.

这个MostAccessed方法有点意思，涉及到sort.Sort的玩法，具体看下面注释：

 1// MostAccessed returns the most accessed items in this cache table
 2//【访问频率高的count条item全部返回】
 3func (table *CacheTable) MostAccessed(count int64) []*CacheItem {
 4    table.RLock()
 5    defer table.RUnlock()
 6    //【这里的CacheItemPairList是[]CacheItemPair类型，是类型不是实例】
 7    //【所以p是长度为len(table.items)的一个CacheItemPair类型的切片类型
 8    p := make(CacheItemPairList, len(table.items))
 9    i := 0
10    //【遍历items，将Key和AccessCount构造成CacheItemPair类型数据存入p切片】
11    for k, v := range table.items {
12        p[i] = CacheItemPair{k, v.accessCount}
13        i++
14    }
15    //【这里可以直接使用Sort方法来排序是因为CacheItemPairList实现了sort.Interface接口，也就是Swap，Len，Less三个方法】
16    //【但是需要留意上面的Less方法在定义的时候把逻辑倒过来了，导致排序是从大到小的】
17    sort.Sort(p)
18
19    var r []*CacheItem
20    c := int64(0)
21    for _, v := range p {
22        //【控制返回值数目】
23        if c >= count {
24            break
25        }
26
27        item, ok := table.items[v.Key]
28        if ok {
29            //【因为数据是按照访问频率从高到底排序的，所以可以从第一条数据开始加】
30            r = append(r, item)
31        }
32        c++
33    }
34
35    return r
36}

17.

最后一个方法了，哇咔咔，好长啊~~~

　　这个函数也没有太多可以讲的，为了方便而整的内部日志函数

　　都看懂了吗？下一讲我们会一口气把cache.go和examples里全部内容放在一起讲完，也就是完成整个项目的分析。3讲看完之后你肯定就对cache2go这个项目有一个全面的了解了！

 

---