【golang项目-GeeCache】动手写分布式缓存 day1

【golang项目-GeeCache】动手写分布式缓存 day1 - 实现LRU算法

news2024/12/30 0:34:38

介绍 LRU 内存淘汰算法

LRU(Least Recently Used) 最近最少使用算法，系统认为如果这个数据最近使用过那么它被再次使用的概率会高，所以系统会先淘汰最久没被使用的数据

基本逻辑

在这里插入图片描述

-----------------------------------------------------------------------出自极客兔兔
k（绿色）为map，即实际中的缓存，当我们读取数据时就是先从这个查询和获取，复杂度为log 级别，非常快
n（红色）为双向链表，用来记录哪个数据是最晚出现的，使用双向链表的原因是为了快速让数据放在队首/队尾，当我们访问一个数据时，我们把这个数据放在链表队首，当我们需要淘汰内存时我们删除队尾的数据，这个数据就是最晚出现的

具体实现

实现数据结构

实现Cache，包含允许的最大缓存，当前的缓存，双向链表，map，回调函数

type Cache struct {
    maxBytes  int64                         // 允许的最大内存
    nbytes    int64                         // 已使用的内存
    ll        *list.List                    //双向链表
    cache     map[string]*list.Element      // map
    OnEvicted func(key string, value Value) //是某条记录被移除时的回调函数
}

实现双向链表的数据类型，便于删除双向链表时根据key删除map的值

type entry struct { // 代表双向链表的数据类型
    key   string
    value Value
}

为了存取数据的通用性，实现Len()获取元素个数

type Value interface {  
	Len() int  
}

初始化缓存函数

func New(maxBytes int64, onEvicted func(string, Value)) *Cache { // 创建
    return &Cache{
        maxBytes:  maxBytes,
        ll:        list.New(),
        cache:     make(map[string]*list.Element),
        OnEvicted: onEvicted,
    }
}

实现查找功能

这个函数首先在缓存（map）中查询是否存在，如果存在就返回这个值，并且把这个值放在双向链表的首部，也标记成最新出现

func (c *Cache) Get(key string) (value Value, ok bool) { // 查找
    if ele, ok := c.cache[key]; ok {
        c.ll.MoveToFront(ele)    // 移动到队首
        kv := ele.Value.(*entry) // 找到值
        return kv.value, true
    }
    return
}

在这里写的时候我对这段代码有疑惑

 kv := ele.Value.(*entry) // 找到值

错误的认为ele.Value.(T) 是 Value中的一个成员变量，但实际又不是
实际上这是接口类型的类型转换 Value.(Type) 是吧接口类型Value转换成Type类型

补充知识：Go语言接口和类型之间的转换

类型断言

类型断言用于将接口类型转换为指定类型，其语法为：
value.(type) 或者 value.(T)

类型转换

类型转换用于将一个接口类型的值转换为另一个接口类型，其语法为：
T(value)

实现内存淘汰功能即删除

内存删除就是移除最近最少访问的节点，就是删除队尾,然后修改当前缓存大小，使用回调函数通知系统

func (c *Cache) RemoveOldest() { // 缓存淘汰
    ele := c.ll.Back() // 取到队首节点，从链表中删除
    if ele != nil {    // 非空
        c.ll.Remove(ele) // 移除最近最少访问
        kv := ele.Value.(*entry)
        delete(c.cache, kv.key)
        c.nbytes -= int64(len(kv.key)) + int64(kv.value.Len())
        if c.OnEvicted != nil {
            c.OnEvicted(kv.key, kv.value) // 回调
        }
    }

}

实现添加/修改数据操作

添加/修改数据时查询缓存是否存在，否则在缓存中（map）中创建个新的键值对，最后把这个数据放在队首，表示最新出现

func (c *Cache) Add(key string, value Value) {
    if ele, ok := c.cache[key]; ok {
        c.ll.MoveToFront(ele)
        kv := ele.Value.(*entry)
        c.nbytes += int64(value.Len()) - int64(kv.value.Len())
        kv.value = value
    } else {
        ele := c.ll.PushFront(&entry{key, value})
        c.cache[key] = ele
        c.nbytes += int64(len(key)) + int64(value.Len())
    }
    for c.maxBytes != 0 && c.maxBytes < c.nbytes {
        c.RemoveOldest() //如果超过了设定的最大值 c.maxBytes，则移除最少访问的节点。

    }

}

全部代码

实现代码

package lru

  

import "container/list"

  

type Cache struct {

    maxBytes  int64                         // 允许的最大内存

    nbytes    int64                         // 已使用的内存

    ll        *list.List                    //双向链表

    cache     map[string]*list.Element      // map

    OnEvicted func(key string, value Value) //是某条记录被移除时的回调函数

}

  

type entry struct { // 代表双向链表的数据类型

    key   string

    value Value

}

  

type Value interface {

    Len() int

}

  

func New(maxBytes int64, onEvicted func(string, Value)) *Cache { // 创建

    return &Cache{

        maxBytes:  maxBytes,

        ll:        list.New(),

        cache:     make(map[string]*list.Element),

        OnEvicted: onEvicted,

    }

}

  

func (c *Cache) Get(key string) (value Value, ok bool) { // 查找

    if ele, ok := c.cache[key]; ok {

        c.ll.MoveToFront(ele)    // 移动到队尾

        kv := ele.Value.(*entry) // 找到值

        return kv.value, true

    }

    return

}

  

func (c *Cache) RemoveOldest() { // 缓存淘汰

    ele := c.ll.Back() // 取到队首节点，从链表中删除

    if ele != nil {    // 非空

        c.ll.Remove(ele) // 移除最近最少访问

        kv := ele.Value.(*entry)

        delete(c.cache, kv.key)

        c.nbytes -= int64(len(kv.key)) + int64(kv.value.Len())

        if c.OnEvicted != nil {

            c.OnEvicted(kv.key, kv.value) // 回调

        }

    }

}

  

func (c *Cache) Add(key string, value Value) {

    if ele, ok := c.cache[key]; ok {

        c.ll.MoveToFront(ele)

        kv := ele.Value.(*entry)

        c.nbytes += int64(value.Len()) - int64(kv.value.Len())

        kv.value = value

    } else {

        ele := c.ll.PushFront(&entry{key, value})

        c.cache[key] = ele

        c.nbytes += int64(len(key)) + int64(value.Len())

    }

    for c.maxBytes != 0 && c.maxBytes < c.nbytes {

        c.RemoveOldest() //如果超过了设定的最大值 c.maxBytes，则移除最少访问的节点。

    }

}

  

func (c *Cache) Len() int {

    return c.ll.Len()

}

测试代码
在这里也可以学会testing库的使用

package lru

  

import (

    "reflect"

    "testing"

)

  

type String string

  

func (d String) Len() int {

    return len(d)

}

  

func TestGet(t *testing.T) {

    lru := New(int64(0), nil)

    lru.Add("key1", String("1234"))

    if v, ok := lru.Get("key1"); !ok || string(v.(String)) != "1234" {

        t.Fatalf("cache hit key1=1234 failed")

    }

    if _, ok := lru.Get("key2"); ok {

        t.Fatalf("cache miss key2 failed")

    }

}

  

func TestRemoveoldest(t *testing.T) {

    k1, k2, k3 := "key1", "key2", "k3"

    v1, v2, v3 := "value1", "value2", "v3"

    cap := len(k1 + k2 + v1 + v2)

    lru := New(int64(cap), nil)

    lru.Add(k1, String(v1))

    lru.Add(k2, String(v2))

    lru.Add(k3, String(v3))

  

    if _, ok := lru.Get("key1"); ok || lru.Len() != 2 {

        t.Fatalf("Removeoldest key1 failed")

    }

}

  

func TestOnEvicted(t *testing.T) {

    keys := make([]string, 0)

    callback := func(key string, value Value) {

        keys = append(keys, key)

    }

    lru := New(int64(10), callback)

    lru.Add("key1", String("123456"))

    lru.Add("k2", String("k2"))

    lru.Add("k3", String("k3"))

    lru.Add("k4", String("k4"))

  

    expect := []string{"key1", "k2"}

  

    if !reflect.DeepEqual(expect, keys) {

        t.Fatalf("Call OnEvicted failed, expect keys equals to %s", expect)

    }

}

  

func TestAdd(t *testing.T) {

    lru := New(int64(0), nil)

    lru.Add("key", String("1"))

    lru.Add("key", String("111"))

  

    if lru.nbytes != int64(len("key")+len("111")) {

        t.Fatal("expected 6 but got", lru.nbytes)

    }

}