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这个项目有一个全面的了解了!

• 编辑
• 预览