关于golang: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
}