• 内存缓存系统

    胤凯 (oyto.github.io)，欢迎到我的博客阅读。

    今天我们围绕一个面试题来实现一个内存缓存系统。

    面试题内容

    1. 支持设置过期时间，精度到秒
    2. 支持设置最大内存，当内存超出时做出合理的处理
    3. 支持并发安全
    4. 按照以下接口要求实现

    1. type Cache interface {
    2.     // SetMaxMemory size : 1KB 100KB 1MB 2MB 1GB
    3.     SetMaxMemory(size string) bool
    4.     // Set 将 value 写入缓存
    5.     Set(key string, val interface{}, expire time.Duration) bool
    6.     // Get 根据 key 值获取 value
    7.     Get(key string) (interface{}, bool)
    8.     // Del 删除 key 值
    9.     Del(key string) bool
    10.     // Exists 判断 key 是否存在
    11.     Exists(key string) bool
    12.     // Flush 清空所有 key
    13.     Flush() bool
    14.     // Keys 获取缓存中所有 key 的数量
    15.     Keys() int64
    16. }

    5. 使用示例

    1. cache := NewMemCache()
    2. cache.SetMaxMemory("100MB")
    3. cache.Set("int", 1)
    4. cache.Set("bool", false)
    5. cache.Set("data", map[string]interface{}{"a": 1})
    6. cache.Get("int")
    7. cache.Del("int")
    8. cache.Flush()
    9. cache.Keys()

    题目分析

    ​    题目乍一看没有什么难点，就依据题目实现对应的接口以及对应的方法就行了。但其实有一个坑，那就是接口中的 `Set` 方法参数和使用示例中的对不上，使用示例中没有传入过期时间。难道是题目出错了？

    ​    显然不是的，这里是需要我们去做一个代理层，去实现一个可选参数的 `Set` 方法。我们可以在实现了带过期时间参数的方法后，再去封装一层，然后设置成可选参数即可。

    ​    这样子，题目的要求，就差不多没什么问题了。但这是面试题，我们想要面试官对我们的评价更好，就要做到更多的内容，寻找一些加分项，比如我们可以增加一个功能，定期删除过期缓存键，又或者我们可以写一些单元测试，让面试官知道我们有写单元测试的好习惯，这些都是一些加分项，能让我们更加地突出。

    动手写代码

    ​    下面就带着大家一步一步来完成这个缓存系统，当然只是一个具有基础的功能缓存系统，大家在后续也可以自行在其中丰富更多的功能。

    构建大体框架

    ​    首先，我们可以先在项目根目录下创建一个 cache 包，然后在 cache 包里创建一个 cache.go 文件，然后将题目中要求实现的接口放在里面：

    1. // cache/cache.go
    2. type Cache interface {
    3.     // SetMaxMemory size : 1KB 100KB 1MB 2MB 1GB
    4.     SetMaxMemory(size string) bool
    5.     // Set 将 value 写入缓存
    6.     Set(key string, val interface{}, expire time.Duration) bool
    7.     // Get 根据 key 值获取 value
    8.     Get(key string) (interface{}, bool)
    9.     // Del 删除 key 值
    10.     Del(key string) bool
    11.     // Exists 判断 key 是否存在
    12.     Exists(key string) bool
    13.     // Flush 清空所有 key
    14.     Flush() bool
    15.     // Keys 获取缓存中所有 key 的数量
    16.     Keys() int64
    17. }

    ​    接着我们再在 cache 包下创建一个 memCache.go 文件，并在该文件中创建一个 memCache 结构体，去实现题目中要求的 Cache 接口：

    1. type memCache struct {
    2. }
    3.  
    4. func (mc *memCache) SetMaxMemory(size string) bool {
    5.     return false
    6. }
    7.  
    8. // Set 将 value 写入缓存
    9. func (mc *memCache) Set(key string, val interface{}, expire time.Duration) bool {
    10.     return false
    11. }
    12.  
    13. // Get 根据 key 值获取 value
    14. func (mc *memCache) Get(key string) (interface{}, bool) {
    15.     return nil, false
    16. }
    17.  
    18. // Del 删除 key 值
    19. func (mc *memCache) Del(key string) bool {
    20.     return true
    21. }
    22.  
    23. // Exists 判断 key 是否存在
    24. func (mc *memCache) Exists(key string) bool {
    25.     return true
    26. }
    27.  
    28. // Flush 清空所有 key
    29. func (mc *memCache) Flush() bool {
    30.     return true
    31. }
    32.  
    33. // Keys 获取缓存中所有 key 的数量
    34. func (mc *memCache) Keys() int64 {
    35.     return 0
    36. }

    ​    可以看到使用样例中有一个 NewMemCache 函数，于是我们还需要在 memCache.go 文件中添加一个 NewMemCache() 函数，返回一个实例，供 main 函数调用：

    1. // cache/memCache.go
    2. func NewMemCache() Cache {
    3.     return &memCache{}
    4. }
    5.


    ​    接着，我们就可以先去主函数 main 中用使用示例跑一下，看看有没有什么问题。在项目根目录下创建一个 main 函数，如下：

    1. // main.go
    2. package main
    3.  
    4. import cache2 "main/cache"
    5.  
    6. func main() {
    7.     cache := cache2.NewMemCache()
    8.     cache.SetMaxMemory("100MB")
    9.     cache.Set("int", 1)
    10.     cache.Set("bool", false)
    11.     cache.Set("data", map[string]interface{}{"a": 1})
    12.     cache.Get("int")
    13.     cache.Del("int")
    14.     cache.Flush()
    15.     cache.Keys()
    16. }

    ​    然后你就会发现报错了，这个问题就是我们上面说的那个坑，这里需要做一个代理层，但为了方便我们可以先修改使用样例，使他能够先跑通，最后再来做一个代理就可以了。

    1. // main.go
    2. cache.Set("int", 1, 3)
    3. cache.Set("bool", false, 1)
    4. cache.Set("data", map[string]interface{}{"a": 1}, 2)

    ​    为了看出效果，我们可以在所有的方法中都打印一个信息，比如 Set 方法中打印 `fmt.Println("我是 Set 方法")。

    ​    最后如果所有的方法都打印出了对应的信息，就说明这个大体框架我们已经搭建好了，下面再去慢慢实现各个方法就可以了。

    逐个实现方法

    ​    下面就带着大家逐个实现每个具体的方法：

    SetMaxMemory

    ​    这个方法是用于设置我们缓存系统的最大缓存大小的，因此我们的 memCache 结构体中，就至少应该需要两个字段：最大内存大小 和当前内存大小，因为我们肯定需要去判断当前内存是否超过了最大内存大小，为了方便，我们再增加一个 最大内存大小字段的字符串表示，如下：

    1. // cache/memCache.go
    2. type memCache struct {
    3.     // 最大内存大小
    4.     maxMemorySize int64
    5.     // 最大内存字符串表示
    6.     maxMemorySizeStr string
    7.     // 当前内存大小
    8.     currMemorySize int64
    9. }

    ​    然后再来看我们的题目要求，`SetMaxMemory size : 1KB 100KB 1MB 2MB 1GB` 要求支持多种单位的表示，所以这里我们肯定需要对输入的内存大小做一个转换，因此我们需要去实现一个 parseSize 函数去解析用户的输入。

    ​    我们在 cache 包下，创建一个 util.go 文件，用于存放一些通用功能和工具函数。

    ​    parseSize 函数的实现思路是：将用户输入的字符串中的数字部分和单位部分分别提取出来，再进行校验和单位转换等的处理。

    ​    利用正则表达式先将用户的输入中的数字部分提取出来，然后再将用户输入的字符串中的数字部分用空格替换，这样剩下的部分就是单位了。

    ​    同样的，将用户输入字符串中的单位部分用空格替换，得到的就是数字部分了。

    ​    接下来，就是对用户的单位做一个转换，这里我们利用 Go 语言中的预定义标识符，采用小技巧来做一个单位的转换，如下：

    1. // cache/util.go
    2. const (
    3.     B = 1 << (iota * 10) // 1
    4.     KB                      // 2024
    5.     MB                   // 1048576
    6.     GB                   // 1073741824
    7.     TB                      // ...
    8.     PB                      // ...
    9. )

    ​    有了不同的单位，我们就可以对解析出来的单位进行处理了，我们这里统一将所有的单位转换成字节，也就是 B：

    1. // cache/util.go
    2. var byteNum int64 = 0
    3. // 1KB 100KB 1MB 2MB 1GB，单位统一为 byte
    4. switch unit {
    5. case "B":
    6.     byteNum = num
    7. case "KB":
    8.     byteNum = num * KB
    9. case "MB":
    10.     byteNum = num * MB
    11. case "GB":
    12.     byteNum = num * GB
    13. case "TB":
    14.     byteNum = num * TB
    15. case "PB":
    16.     byteNum = num * PB
    17. default: // 设置不合法，设置为 0，后续设置为 默认值
    18.     num = 0
    19. }

    ​    如果用户输入的单位不合法，就是通过后续处理设置为默认值 100MB：

    1. // cache/util.go
    2. // 用户使用不合法，打印日志并设置默认值
    3. if num == 0 {
    4.     log.Println("ParseSize 仅支持 B、KB、MB、GB、TB、PB")
    5.     num = 100
    6.     byteNum = num * MB
    7.     unit = "MB"
    8. }

    ​    最后由于我们需要返回的有两种形式，即字符串形式和数字形式，所以这里还需要拼接一下字符串形式。这里没有直接使用用户传入的值，是因为可能用户的输入有问题，然后我们采用的是默认值，故这里直接统一全部重新拼接：

    1. // cache/util.go
    2. sizeStr := strconv.FormatInt(num, 10) + unit

    ```

    ​    至此，ParseSize 函数，我们就实现完毕了，完整代码如下：

    1. // ParseSize 单位统一，并且检查设置是否正确
    2. func ParseSize(size string) (int64, string) {
    3.     // 默认大小为 100
    4.  
    5.     // 利用正则表达式匹配一个或者多个数字
    6.     re, _ := regexp.Compile("[0-9]+")
    7.     // 获取单位：使用编译好的正则表达式 re，将 size 字符串中匹配的数字字符替换为空字符串
    8.     unit := string(re.ReplaceAll([]byte(size), []byte("")))
    9.     // 单位转换为大写
    10.     unit = strings.ToUpper(unit)
    11.  
    12.     // 获取数字：将 size 字符串中的单位部分 unit 用空字符串替换，即可获取数字部分。最后再将数字转换为 int64 类型
    13.     num, _ := strconv.ParseInt(strings.Replace(size, unit, "", 1), 10, 64)
    14.  
    15.     var byteNum int64 = 0
    16.     // 1KB 100KB 1MB 2MB 1GB，单位统一为 byte
    17.     switch unit {
    18.     case "B":
    19.         byteNum = num
    20.     case "KB":
    21.         byteNum = num * KB
    22.     case "MB":
    23.         byteNum = num * MB
    24.     case "GB":
    25.         byteNum = num * GB
    26.     case "TB":
    27.         byteNum = num * TB
    28.     case "PB":
    29.         byteNum = num * PB
    30.     default: // 设置不合法，设置为 0，后续设置为 默认值
    31.         num = 0
    32.     }
    33.  
    34.     // 用户使用不合法，打印日志并设置默认值
    35.     if num == 0 {
    36.         log.Println("ParseSize 仅支持 B、KB、MB、GB、TB、PB")
    37.         num = 100
    38.         byteNum = num * MB
    39.         unit = "MB"
    40.     }
    41.  
    42.     sizeStr := strconv.FormatInt(num, 10) + unit
    43.     return byteNum, sizeStr
    44. }

     ​    然后我们的 SetMaxMemory 函数就简单了，如下：

    1. // cache/memCache.go
    2. func (mc *memCache) SetMaxMemory(size string) bool {
    3.     mc.maxMemorySize, mc.maxMemorySizeStr = ParseSize(size)
    4.     fmt.Println(mc.maxMemorySize, mc.maxMemorySizeStr)
    5.     return true
    6. }

    ​    然后我们可以运行 main.go 函数，打印一下检查是否有问题：

    1. $ go run main.go
    2. 104857600 100MB

    ​    可以用计算器算一下，没有问题，我们的 SetMaxMemory 函数就完成了。

    Set

    ​    然后是我们的 Set 方法，这个方法是用来将键值对存入我们的缓存系统中的。

    ​    首先，我们需要考虑用什么类型来存储键值对，很自然就可以想到用 Go 语言内置的字典，即 map 来实现。那新的问题又来了，那 map 的 key-value 分别用什么类型呢？key 的类型，毫无疑问肯定是 string 类型；value 的类型的话，这里如果也用一个单独的 interface{} 类型的话，可能也会存在一些问题，因为我们的 value 需要携带很多附加信息，比如 value 的值、过期时间、value 大小等，故这里的 value 需要用一个结构体去表示，故我们要先创建一个 memCacheValue 结构体：

    1. // cahce.memCache.go
    2. type memCacheValue struct {
    3.     // value 值
    4.     val interface{}
    5.     // 过期时间
    6.     expireTime time.Time
    7.     // 有效时长
    8.     expire time.Duration
    9.     // value 大小。用于计算当前内存大小
    10.     size int64
    11. }

    ​    有了 memCacheValue，就可以在 memCache 中新增一个字段了：

    1. // cahce.memCache.go
    2. type memCache struct {
    3.     // 最大内存大小
    4.     maxMemorySize int64
    5.     // 最大内存字符串表示
    6.     maxMemorySizeStr string
    7.     // 当前内存大小
    8.     currMemorySize int64
    9.     // 缓存键值对
    10.     values map[string]*memCacheValue
    11. }

    ​    由于这里使用了 map，故在初始化 memCache 实例的时候，需要进行内存的分配，所以我们要修改 NewMemCache 函数：

    1. // cahce.memCache.go
    2. func NewMemCache() Cache {
    3.     mc := &memCache{
    4.         values: make(map[string]*memCacheValue),
    5.     }
    6.     return mc
    7. }

    ​    言归正传，继续分析我们的 Set 方法的实现，由于 Set 方法是写操作，Map 并非线程安全的，所以我们在进行写操作的时候需要进行加锁保护，故这里 memCache 结构中还需要加一个锁：

    1. type memCache struct {
    2.     ...
    3.     // 读写锁
    4.     locker sync.RWMutex
    5. }

    ​    这里我们采用读写锁，这样可以利用 map 的读写机制：读操作兼容、写操作互斥，最大化提升读写 map 的性能。

    ​    因为我们的键可能存在过期时间，如果是重复 Set 一个已存在的值，就需要去重新计算更新对应的时间，会需要分情况讨论，比较复杂。所以，这里我们统一使用，先删除对应键值，再添加对应键值，写起来会比较方便，下面我们实现三个方法，以便我们调用：

    1. // 判断是否存在对应的 value
    2. func (mc *memCache) get(key string) (*memCacheValue, bool) {
    3.     val, ok := mc.values[key]
    4.     return val, ok
    5. }
    6.  
    7. // 删除：当前内存大小更新、删除当前 key 值
    8. func (mc *memCache) del(key string) {
    9.     tmp, ok := mc.get(key)
    10.     if ok && tmp != nil {
    11.         mc.currMemorySize -= tmp.size
    12.         delete(mc.values, key)
    13.     }
    14. }
    15.  
    16. // 添加：当前内存大小更新、删除当前 key 值
    17. func (mc *memCache) add(key string, val *memCacheValue) {
    18.     mc.values[key] = val
    19.     mc.currMemorySize += val.size
    20. }

    ​    上述三个方法比较简单，就不做过多赘述了。有了这三个函数，我们后面其他的方法实现起来，都会很简单。

    ​    然后我们的 Set 方法就可以写了：

    1. func (mc *memCache) Set(key string, val interface{}, expire time.Duration) bool {
    2.     // map 非线程安全需要加锁访问
    3.     mc.locker.Lock()
    4.     defer mc.locker.Unlock()
    5.     // 确定一个 value 值
    6.     v := &memCacheValue{
    7.         val:        val,
    8.         expireTime: time.Now().Add(expire),
    9.         expire:     expire,
    10.         size:       GetValSize(val),
    11.     }
    12.     // 为了简化代码复杂度，这里用 “删除再添加” 来代替 “更新” 操作
    13.     if _, ok := mc.get(key); ok { // 存在则删除
    14.         mc.del(key)
    15.     }
    16.     mc.add(key, v)
    17.  
    18.     // 新增后缓存是否超过最大内存：超过则直接删除刚刚添加的这个 key，并报 panic
    19.     if mc.currMemorySize > mc.maxMemorySize {
    20.         mc.del(key)
    21.         // 这里可以自己完善一下，通过一些内存淘汰策略来选择删除一些 key，来判断是否还会超过最大内存
    22.         log.Println(fmt.Sprintf("max memory size %s", mc.maxMemorySizeStr))
    23.     }
    24.     return false
    25. }

    1. 在开始操作之前，加写锁保护
    2. 根据用户输入，构建对应的 value 值
    3. 如果存在对应键值对，就先删除，然后再添加对应键值
    4. 新增后判断是否超过内存，超过了的话，就直接删除刚刚添加的这个键

    ​    上述 Set 方法中还用到一个函数 GetValSize ，我们可以先不去实现这个函数具体逻辑，后面再回过头来看：

    1. // cache/util.go
    2. // GetValSize 计算 value 值大小
    3. func GetValSize(val interface{}) int64 {
    4.     return 0
    5. }
    Get

    ​    Get 方法，是根据用户输入的键，来获取对应的 value 值的。实现很简单，如下：

    1. func (mc *memCache) Get(key string) (interface{}, bool) {
    2.     mc.locker.RLock()
    3.     defer mc.locker.RUnlock()
    4.  
    5.     // 拿到对应的值
    6.     mcv, ok := mc.get(key)
    7.     // 判断是否过期
    8.     if ok {
    9.         if mcv.expire != 0 && mcv.expireTime.Before(time.Now()) { // 过期时间早于当前时间，删除
    10.             mc.del(key)
    11.             return nil, false
    12.         }
    13.         return mcv.val, ok
    14.     }
    15.     return nil, false
    16. }

    1. 加读锁保护
    2. 先通过 get 方法拿到对应的值
    3. 如果存在该键，且该值没有过期或者没有过期时间，则返回该值
    4. 否则返回 nil，并删除该过期键

    Del

    ​    Del 方法，是用于删除对应键值对的。直接加写锁操作，并调用先前实现的 del 函数即可：

    1. func (mc *memCache) Del(key string) bool {
    2.     mc.locker.Lock()
    3.     defer mc.locker.Unlock()
    4.     mc.del(key)
    5.     return true
    6. }

    1. 加写锁保护
    2. 直接调用 del 函数进行删除对应键值对即可

    Exists

    ​    Exists 方法，用于判断某个键是否存在于我们的缓存系统。实现也非常简单：

    1. func (mc *memCache) Exists(key string) bool {
    2.     mc.locker.RLock()
    3.     defer mc.locker.RUnlock()
    4.     _, ok := mc.values[key]
    5.     return ok
    6. }

    1. 加读锁保护
    2. 直接获取对应键值对，以此判断是否存在该键

    Flush

    ​    Flush 方法，是在整个缓存系统的缓存数据不需要使用之后，用来清空所有的缓存时使用的。这里我们利用 Go 语言的垃圾回收机制，直接将整个 map 置空，Go 语言的垃圾回收机制会直接将没有使用的内存进行回收：

    1. func (mc *memCache) Flush() bool {
    2.     mc.locker.Lock()
    3.     defer mc.locker.Unlock()
    4.     // 直接将整个 map 置空，go 的垃圾回收机制会自行将没有使用的内存进行回收
    5.     mc.values = make(map[string]*memCacheValue, 0)
    6.     mc.currMemorySize = 0
    7.  
    8.     return true
    9. }

    1. 加写锁保护
    2. 将整个 map 置空，并将当前使用内存大小清空

    Keys

    ​    Keys 方法，用于获取缓存中 key 的数量。直接用 len() 函数获取即可：

    1. func (mc *memCache) Keys() int64 {
    2.     mc.locker.RLock()
    3.     defer mc.locker.RUnlock()
    4.     return int64(len(mc.values))
    5. }

    1. 加读锁保护
    2. 利用 len() 函数直接获取

    ​    

    ​    现在我们再来看看这个 GetValSize 函数，这里有两种思路实现：

    1. 利用反射包 `unsafe.Sizeof(val)` 来获取对应的值的大小
    2. 野路子：利用 json 包，将 val 序列化为字节数组，然后求字节数组的长度，就知道该值占用了多少字节了

    ​    通过测试，可以发现第一种方法是不可靠的，因为`unsafe.Sizeof()` 方法只是算出对应类型的字节大小，而不是你所存储的内容的具体大小。于是我们这里采用第二种方法来实现：

    1. // cache/util.go
    2. // GetValSize 计算 value 值大小
    3. func GetValSize(val interface{}) int64 {
    4.     // 野路子：利用 json 包，将 val 序列化为字节数组，然后求字节数组的长度，就知道占用了多少字节了
    5.     bytes, _ := json.Marshal(val)
    6.     size := int64(len(bytes))
    7.     return size
    8. }

    ​    至此，我们的基础功能，就差不多实现了。大家可以通过在 main 函数打印对应的信息来检查。在这里，我就不再带着大家检查了。

    实现代理层

    ​    首先我们得明白，为什么要再加一层代理层？在这里，题目给的接口是包含过期时间的，但是我们的使用示例却没有使用过期时间，这就是说明需要加一层代理层来进行封装。

    ​    添加代理层还有一些好处，比如：

    - 安全性：它可以过滤和阻止对系统的未经授权的访问，通过身份验证和授权机制确保只有合法的用户或服务可以访问底层的资源。这有助于防范潜在的安全威胁。
    - 性能优化：代理层可以缓存某些请求的结果，以避免重复计算或数据库查询。此外，代理层还可以对请求进行负载均衡，确保各个后端服务得到合理的分配，以提高整体性能。
    - 抽象底层实现： 代理层可以用于隐藏底层实现的复杂性，提供简化的接口给上层系统。这有助于实现系统的模块化和降低耦合度，使得系统更容易维护和扩展。

    ​    下面我们来看看怎么实现代理层：

    ​    首先，在项目根目录创建一个文件夹 cache-server ，并在该目录下创建一个 cache.go 文件，完整代码如下：

    1. package cache_server
    2.  
    3. import (
    4.     "main/cache"
    5.     "time"
    6. )
    7.  
    8. // 代理层/适配层
    9. type cacheServer struct {
    10.     memCache cache.Cache
    11. }
    12.  
    13. func NewMemCache() *cacheServer {
    14.     return &cacheServer{
    15.         memCache: cache.NewMemCache(),
    16.     }
    17. }
    18.  
    19. // SetMaxMemory size : 1KB 100KB 1MB 2MB 1GB
    20. func (cs *cacheServer) SetMaxMemory(size string) bool {
    21.     return cs.memCache.SetMaxMemory(size)
    22. }
    23.  
    24. // Set 将 value 写入缓存
    25. // 代理层：将 有效时长参数设置为可有可无
    26. func (cs *cacheServer) Set(key string, val interface{}, expire ...time.Duration) bool {
    27.     // 默认值为 0 秒
    28.     expireTs := time.Second * 0
    29.     if len(expire) > 0 {
    30.         expireTs = expire[0]
    31.     }
    32.     return cs.memCache.Set(key, val, expireTs)
    33. }
    34.  
    35. // Get 根据 key 值获取 value
    36. func (cs *cacheServer) Get(key string) (interface{}, bool) {
    37.     return cs.memCache.Get(key)
    38. }
    39.  
    40. // Del 删除 key 值
    41. func (cs *cacheServer) Del(key string) bool {
    42.     return cs.memCache.Del(key)
    43. }
    44.  
    45. // Exists 判断 key 是否存在
    46. func (cs *cacheServer) Exists(key string) bool {
    47.     return cs.memCache.Exists(key)
    48. }
    49.  
    50. // Flush 清空所有 key
    51. func (cs *cacheServer) Flush() bool {
    52.     return cs.memCache.Flush()
    53. }
    54.  
    55. // Keys 获取缓存中所有 key 的数量
    56. func (cs *cacheServer) Keys() int64 {
    57.     return cs.memCache.Keys()
    58. }

    1. 首先我们仍然需要先将 cache 接口封装起来，并写一个构造函数返回一个实例
    2. 除了 Set 方法外，其他方法直接调用实现即可
    3. 在 Set 方法中，将过期时间参数设置为可选参数，即 `expire ...time.Duration`，然后通过判断是否传入该参数来构建新的参数 `expireTs` 去调用实现好的方法

    ​    实现完成后，我们就可以将 main 函数的代码修改一下，调用代理层提供的方法来进行使用：

    1. package main
    2.  
    3. import (
    4.     cache_server "main/cache-server"
    5. )
    6.  
    7. func main() {
    8.     cache := cache_server.NewMemCache()
    9.     cache.SetMaxMemory("100MB")
    10.     cache.Set("int", 1)
    11.     cache.Set("bool", false)
    12.     cache.Set("data", map[string]interface{}{"a": 1})
    13.     cache.Get("int")
    14.     cache.Del("int")
    15.     cache.Flush()
    16.     cache.Keys()
    17. }

    ​    这样，即使我们不使用带过期时间的 Set 方法，也不会报错了。

    加分项

    ​    最后我们再来看看我们的加分项：

    轮询检查删除过期键

    ​    我们可以在创建缓存系统实例的时候，同时开启我们的 ” 轮询检查删除过期键 “ 功能。

    1. func NewMemCache() Cache {
    2.     mc := &memCache{
    3.         values:                       make(map[string]*memCacheValue),
    4.         cleanExpiredItemTimeInterval: time.Second, // 定期清理缓存
    5.     }
    6.     // 轮询检查删除过期键
    7.     go mc.cleanExpiredItem()
    8.     return mc
    9. }

    ​    这里需要新添加一个字段 `cleanExpiredItemTimeInterval` 表示清理周期，还需要写一个轮询的函数，如下：

    1. type memCache struct {
    2.     ...
    3.     // 清楚过期缓存时间间隔
    4.     cleanExpiredItemTimeInterval time.Duration
    5. }

    ​    下面是轮询的函数：

    1. // 轮询清空过期 key
    2. func (mc *memCache) cleanExpiredItem() {
    3.     // 设置一个定时触发器：定时向 Ticker.C 中发送一个消息，即触发了一次
    4.     timeTicker := time.NewTicker(mc.cleanExpiredItemTimeInterval)
    5.     defer timeTicker.Stop()
    6.     for {
    7.         select {
    8.         case <-timeTicker.C: // 每个周期做一个缓存清理
    9.             // 遍历所有缓存的键值对，将有过期时间且过期的键删除掉
    10.             for key, item := range mc.values {
    11.                 if item.expire != 0 && time.Now().After(item.expireTime) {
    12.                     mc.locker.Lock()
    13.                     mc.del(key)
    14.                     mc.locker.Unlock()
    15.                 }
    16.             }
    17.         }
    18.     }
    19. }

    1. 采用 `time.NewTicker`，定义一个制定周期的定时器
    2. 由于需要不断轮询，故需要放在 for 循环中
    3. 配合 select 实现一个阻塞式的轮询检查并删除过期键的操作操作

    单元测试

    ​    单元测试是一种用于验证程序各个独立单元是否能按照预期工作的测试方法。Go语言的测试工具内置于语言本身，通过 `testing` 包提供了一套简单而有效的测试框架。平时不论是学习、还是工作，都应该养成写单元测试的习惯。

    ​    我们在 cache 包下，创建一个 memCache_test.go 文件，并在里面写我们测试内容：

    1. package cache
    2.  
    3. import (
    4.     "testing"
    5.     "time"
    6. )
    7.  
    8. func TestCacheOP(t *testing.T) {
    9.     testData := []struct {
    10.         key    string
    11.         val    interface{}
    12.         expire time.Duration
    13.     }{
    14.         {"baer", 678, time.Second * 10},
    15.         {"hrws", false, time.Second * 11},
    16.         {"gddfas", true, time.Second * 12},
    17.         {"rwe", map[string]interface{}{"a": 3, "b": false}, time.Second * 13},
    18.         {"rqew", "fsdfas", time.Second * 14},
    19.         {"fsdew", "这里是字符串这里是字符串这里是字符串", time.Second * 15},
    20.     }
    21.  
    22.     c := NewMemCache()
    23.     c.SetMaxMemory("10MB")
    24.     // 测试 set 和 get
    25.     for _, item := range testData {
    26.         c.Set(item.key, item.val, item.expire)
    27.         val, ok := c.Get(item.key)
    28.         if !ok {
    29.             t.Error("缓存取值失败")
    30.         }
    31.         if item.key != "rwe" && val != item.val {
    32.             t.Error("缓存取值数据与预期不一致")
    33.         }
    34.         _, ok1 := val.(map[string]interface{})
    35.         if item.key == "rwe" && !ok1 {
    36.             t.Error("缓存取值数据与预期不一致")
    37.         }
    38.     }
    39.     // 测试 Keys()
    40.     if int64(len(testData)) != c.Keys() {
    41.         t.Error("缓存数量不一致")
    42.     }
    43.     // 测试 Del()
    44.     c.Del(testData[0].key)
    45.     c.Del(testData[1].key)
    46.  
    47.     if int64(len(testData)) != c.Keys()+2 {
    48.         t.Error("缓存数量不一致")
    49.     }
    50.  
    51.     // 测试过期时间
    52.     time.Sleep(time.Second * 16)
    53.  
    54.     if c.Keys() != 0 {
    55.         t.Error("缓存清空失败")
    56.     }
    57. }

    先用匿名结构体，构建需要用到的各类测试数据

    然后对 Set、Get、Del 等方法进行调用，然后对比结果

    小结

    ​    这篇文章，通过一个面试题，从题目到各种坑点的分析，带大家了解并实现了一个简易版的 内存缓存系统  。相信大家在看完后肯定会收货满满。

    完整代码

    这是项目的目录结构：

    下面会给出各个文件的内容：

    main.go
    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     cacheserver "main/cache-server"
    6.     "time"
    7. )
    8.  
    9. func main() {
    10.     cache := cache_server.NewMemCache()
    11.     cache.SetMaxMemory("100MB")
    12.     cache.Set("int", 1)
    13.     cache.Set("bool", false)
    14.     cache.Set("data", map[string]interface{}{"a": 1})
    15.     cache.Get("int")
    16.     cache.Del("int")
    17.     cache.Flush()
    18.     cache.Keys()
    19. }
    cache/cache.go
    1. package cache
    2.  
    3. import "time"
    4.  
    5. type Cache interface {
    6.     SetMaxMemory(size string) bool
    7.     Set(key string, val interface{}, expire time.Duration) bool
    8.     Get(key string) (interface{}, bool)
    9.     Del(key string) bool
    10.     Exists(key string) bool
    11.     Flush() bool
    12.     Keys() int64
    13. }
    cache/memCache.go
    1. package cache
    2.  
    3. import (
    4.     "fmt"
    5.     "log"
    6.     "sync"
    7.     "time"
    8. )
    9.  
    10. type memCache struct {
    11.     maxMemorySize int64
    12.     maxMemorySizeStr string
    13.     currMemorySize int64
    14.     values map[string]*memCacheValue
    15.     locker sync.RWMutex
    16.     cleanExpiredItemTimeInterval time.Duration
    17. }
    18.  
    19. type memCacheValue struct {
    20.     val interface{}
    21.     expireTime time.Time
    22.     expire time.Duration
    23.     size int64
    24. }
    25.  
    26. func NewMemCache() Cache {
    27.     mc := &memCache{
    28.         values:                       make(map[string]*memCacheValue),
    29.         cleanExpiredItemTimeInterval: time.Second, 
    30.     }
    31.     go mc.cleanExpiredItem()
    32.     return mc
    33. }
    34.  
    35. func (mc *memCache) SetMaxMemory(size string) bool {
    36.     mc.maxMemorySize, mc.maxMemorySizeStr = ParseSize(size)
    37.     return true
    38. }
    39.  
    40. func (mc *memCache) Set(key string, val interface{}, expire time.Duration) bool {
    41.     mc.locker.Lock()
    42.     defer mc.locker.Unlock()
    43.     v := &memCacheValue{
    44.         val:        val,
    45.         expireTime: time.Now().Add(expire),
    46.         expire:     expire,
    47.         size:       GetValSize(val),
    48.     }
    49.     if _, ok := mc.get(key); ok {
    50.         mc.del(key)
    51.     }
    52.     mc.add(key, v)
    53.  
    54.     if mc.currMemorySize > mc.maxMemorySize {
    55.         mc.del(key)
    56.         log.Println(fmt.Sprintf("max memory size %s", mc.maxMemorySizeStr))
    57.     }
    58.     return false
    59. }
    60.  
    61. func (mc *memCache) get(key string) (*memCacheValue, bool) {
    62.     val, ok := mc.values[key]
    63.     return val, ok
    64. }
    65.  
    66. func (mc *memCache) del(key string) {
    67.     tmp, ok := mc.get(key)
    68.     if ok && tmp != nil {
    69.         mc.currMemorySize -= tmp.size
    70.         delete(mc.values, key)
    71.     }
    72. }
    73.  
    74. func (mc *memCache) add(key string, val *memCacheValue) {
    75.     mc.values[key] = val
    76.     mc.currMemorySize += val.size
    77. }
    78.  
    79. func (mc *memCache) Get(key string) (interface{}, bool) {
    80.     mc.locker.RLock()
    81.     defer mc.locker.RUnlock()
    82.  
    83.     mcv, ok := mc.get(key)
    84.     if ok {
    85.         if mcv.expire != 0 && mcv.expireTime.Before(time.Now()) {
    86.             mc.del(key)
    87.             return nil, false
    88.         }
    89.         return mcv.val, ok
    90.     }
    91.     return nil, false
    92. }
    93.  
    94. func (mc *memCache) Del(key string) bool {
    95.     mc.locker.Lock()
    96.     defer mc.locker.Unlock()
    97.     mc.del(key)
    98.     return true
    99. }
    100.  
    101. func (mc *memCache) Exists(key string) bool {
    102.     mc.locker.RLock()
    103.     defer mc.locker.RUnlock()
    104.     _, ok := mc.values[key]
    105.     return ok
    106. }
    107.  
    108. func (mc *memCache) Flush() bool {
    109.     mc.locker.Lock()
    110.     defer mc.locker.Unlock()
    111.     mc.values = make(map[string]*memCacheValue, 0)
    112.     mc.currMemorySize = 0
    113.  
    114.     return true
    115. }
    116.  
    117. func (mc *memCache) Keys() int64 {
    118.     mc.locker.RLock()
    119.     defer mc.locker.RUnlock()
    120.     return int64(len(mc.values))
    121. }
    122.  
    123. func (mc *memCache) cleanExpiredItem() {
    124.     timeTicker := time.NewTicker(mc.cleanExpiredItemTimeInterval)
    125.     defer timeTicker.Stop()
    126.     for {
    127.         select {
    128.         case <-timeTicker.C: 
    129.             for key, item := range mc.values {
    130.                 if item.expire != 0 && time.Now().After(item.expireTime) {
    131.                     mc.locker.Lock()
    132.                     mc.del(key)
    133.                     mc.locker.Unlock()
    134.                 }
    135.             }
    136.         }
    137.     }
    138. }
    cache/memCache_test.go
    1. package cache
    2.  
    3. import (
    4.     "testing"
    5.     "time"
    6. )
    7.  
    8. func TestCacheOP(t *testing.T) {
    9.     testData := []struct {
    10.         key    string
    11.         val    interface{}
    12.         expire time.Duration
    13.     }{
    14.         {"baer", 678, time.Second * 10},
    15.         {"hrws", false, time.Second * 11},
    16.         {"gddfas", true, time.Second * 12},
    17.         {"rwe", map[string]interface{}{"a": 3, "b": false}, time.Second * 13},
    18.         {"rqew", "fsdfas", time.Second * 14},
    19.         {"fsdew", "这里是字符串这里是字符串这里是字符串", time.Second * 15},
    20.     }
    21.  
    22.     c := NewMemCache()
    23.     c.SetMaxMemory("10MB")
    24.     
    25.     for _, item := range testData {
    26.         c.Set(item.key, item.val, item.expire)
    27.         val, ok := c.Get(item.key)
    28.         if !ok {
    29.             t.Error("缓存取值失败")
    30.         }
    31.         if item.key != "rwe" && val != item.val {
    32.             t.Error("缓存取值数据与预期不一致")
    33.         }
    34.         _, ok1 := val.(map[string]interface{})
    35.         if item.key == "rwe" && !ok1 {
    36.             t.Error("缓存取值数据与预期不一致")
    37.         }
    38.     }
    39.     
    40.     if int64(len(testData)) != c.Keys() {
    41.         t.Error("缓存数量不一致")
    42.     }
    43.     
    44.     c.Del(testData[0].key)
    45.     c.Del(testData[1].key)
    46.  
    47.     if int64(len(testData)) != c.Keys()+2 {
    48.         t.Error("缓存数量不一致")
    49.     }
    50.  
    51.     time.Sleep(time.Second * 16)
    52.  
    53.     if c.Keys() != 0 {
    54.         t.Error("缓存清空失败")
    55.     }
    56. }
    cache/util.go
    1. package cache
    2.  
    3. import (
    4.     "encoding/json"
    5.     "log"
    6.     "regexp"
    7.     "strconv"
    8.     "strings"
    9. )
    10.  
    11. const (
    12.     B = 1 << (iota * 10)
    13.     KB
    14.     MB
    15.     GB
    16.     TB
    17.     PB
    18. )
    19.  
    20. func ParseSize(size string) (int64, string) {
    21.     re, _ := regexp.Compile("[0-9]+")
    22.     
    23.     unit := string(re.ReplaceAll([]byte(size), []byte("")))
    24.     
    25.     unit = strings.ToUpper(unit)
    26.  
    27.     num, _ := strconv.ParseInt(strings.Replace(size, unit, "", 1), 10, 64)
    28.  
    29.     var byteNum int64 = 0
    30.     switch unit {
    31.     case "B":
    32.         byteNum = num
    33.     case "KB":
    34.         byteNum = num * KB
    35.     case "MB":
    36.         byteNum = num * MB
    37.     case "GB":
    38.         byteNum = num * GB
    39.     case "TB":
    40.         byteNum = num * TB
    41.     case "PB":
    42.         byteNum = num * PB
    43.     default: 
    44.         num = 0
    45.     }
    46.  
    47.     if num == 0 {
    48.         log.Println("ParseSize 仅支持 B、KB、MB、GB、TB、PB")
    49.         num = 100
    50.         byteNum = num * MB
    51.         unit = "MB"
    52.     }
    53.  
    54.     sizeStr := strconv.FormatInt(num, 10) + unit
    55.     return byteNum, sizeStr
    56. }
    57.  
    58. func GetValSize(val interface{}) int64 {
    59.     bytes, _ := json.Marshal(val)
    60.     size := int64(len(bytes))
    61.     return size
    62. }
    cache-server/cache.go
    1. package cache_server
    2.  
    3. import (
    4.     "main/cache"
    5.     "time"
    6. )
    7.  
    8. type cacheServer struct {
    9.     memCache cache.Cache
    10. }
    11.  
    12. func NewMemCache() *cacheServer {
    13.     return &cacheServer{
    14.         memCache: cache.NewMemCache(),
    15.     }
    16. }
    17.  
    18. func (cs *cacheServer) SetMaxMemory(size string) bool {
    19.     return cs.memCache.SetMaxMemory(size)
    20. }
    21.  
    22. func (cs *cacheServer) Set(key string, val interface{}, expire ...time.Duration) bool {
    23.     expireTs := time.Second * 0
    24.     if len(expire) > 0 {
    25.         expireTs = expire[0]
    26.     }
    27.     return cs.memCache.Set(key, val, expireTs)
    28. }
    29.  
    30. func (cs *cacheServer) Get(key string) (interface{}, bool) {
    31.     return cs.memCache.Get(key)
    32. }
    33.  
    34. func (cs *cacheServer) Del(key string) bool {
    35.     return cs.memCache.Del(key)
    36. }
    37.  
    38. func (cs *cacheServer) Exists(key string) bool {
    39.     return cs.memCache.Exists(key)
    40. }
    41.  
    42. func (cs *cacheServer) Flush() bool {
    43.     return cs.memCache.Flush()
    44. }
    45.  
    46. func (cs *cacheServer) Keys() int64 {
    47.     return cs.memCache.Keys()
    48. }

  • 相关阅读:
    华纳云：linux怎么查看Raid磁盘阵列信息
    Rust错误处理简介
    Verilog：【3】边沿检测器（edge_detect.sv）
    03-3.1.3 栈的链式存储的实现
    NET 8 预览版 2 亮点是Blazor
    树莓派 ubuntu18.04安装ROS
    Docker进阶：深入了解容器数据卷
    Ceph分布式存储：资源池Pool的管理与MDS、RBD、RGW接口的部署
    操作系统中文件系统的实现和分配方式探析（上）
    Qt之Windows Server 2012 R2不支持openssl
  • 原文地址：https://blog.csdn.net/m0_62264224/article/details/134331950