zoukankan      html  css  js  c++  java
  • cache2go

     

    今天我们来看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这个项目有一个全面的了解了!

  • 相关阅读:
    hlgoj 1766 Cubing
    Reverse Linked List
    String to Integer
    Bitwise AND of Numbers Range
    Best Time to Buy and Sell Stock III
    First Missing Positive
    Permutation Sequence
    Next Permutation
    Gray Code
    Number of Islands
  • 原文地址:https://www.cnblogs.com/cloudgeek/p/9201316.html
Copyright © 2011-2022 走看看