Golang实现简单的LRU缓存

LRU缓存容器有最大的缓存使用限制，超出限制的新增操作会淘汰掉最近最少使用的内容。

实现的思路就是，使用链表来维护淘汰key的优先级，达到最大容量限制就淘汰优先级最低的。

type LRU struct {
    size int        // 限制使用缓存数据个数
    ll   *list.List    // 维护淘汰优先级
    m    map[string]*list.Element // 存储kv

    mu sync.Mutex    // 竞争同步
}

type keyValue struct {
    key string
    val interface{}
}

func New(size int) *LRU {
    lru := &LRU{
        size: size,
        ll:   list.New(),
        m:    make(map[string]*list.Element),
        mu:   sync.Mutex{},
    }
    return lru
}

func (lru *LRU) Add(key string, value interface{}) error {
    lru.mu.Lock()
    defer lru.mu.Unlock()
    if _, ok := lru.m[key]; ok {
        return errors.New("key already exists in LRU")
    }
    if len(lru.m) == lru.size {
        lru.removeOldest()
    }
    val := &keyValue{
        key: key,
        val: value,
    }
    ele := lru.ll.PushFront(val)
    lru.m[key] = ele
    return nil
}

func (lru *LRU) removeOldest() {
    ele := lru.ll.Back()
    lru.ll.Remove(ele)
    kv := ele.Value.(*keyValue)
    delete(lru.m, kv.key)
}

func (lru *LRU) Get(key string) interface{} {
    ele, ok := lru.m[key]
    if ok {
        lru.ll.MoveToFront(ele)
        kv := ele.Value.(*keyValue)
        return kv.val
    }
    return nil
}