cachetable分析

CloudGeek · · 1259 次点击 · · 开始浏览    
这是一个创建于 的文章,其中的信息可能已经有所发展或是发生改变。

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

 


有疑问加站长微信联系(非本文作者)

入群交流(和以上内容无关):加入Go大咖交流群,或添加微信:liuxiaoyan-s 备注:入群;或加QQ群:1006366459

1259 次点击  
加入收藏 微博
被以下专栏收入,发现更多相似内容
暂无回复
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传