Go缓存系统：HashMap与LRU策略结合

在Go语言中，可以使用sync.Map来实现一个简单的缓存系统，它是一个并发安全的map。然而，sync.Map并不支持LRU（Least Recently Used）策略。为了实现一个支持LRU策略的缓存系统，我们可以使用container/list包来维护一个双向链表，以及使用sync.Mutex或sync.RWMutex来保证线程安全。

下面是一个简单的示例，展示了如何将sync.Map与LRU策略结合使用：

package main

import (
	"container/list"
	"fmt"
	"sync"
	"time"
)

type LRUCache struct {
	capacity int
	cache    map[string]*list.Element
	ll       *list.List
	mu       sync.Mutex
}

type entry struct {
	key   string
	value interface{}
}

func NewLRUCache(capacity int) *LRUCache {
	return &LRUCache{
		capacity: capacity,
		cache:    make(map[string]*list.Element),
		ll:       list.New(),
	}
}

func (c *LRUCache) Get(key string) (interface{}, bool) {
	c.mu.Lock()
	defer c.mu.Unlock()

	if elem, ok := c.cache[key]; ok {
		c.ll.MoveToFront(elem)
		return elem.Value.(*entry).value, true
	}
	return nil, false
}

func (c *LRUCache) Put(key string, value interface{}) {
	c.mu.Lock()
	defer c.mu.Unlock()

	if elem, ok := c.cache[key]; ok {
		c.ll.MoveToFront(elem)
		elem.Value.(*entry).value = value
	} else {
		if len(c.cache) >= c.capacity {
			last := c.ll.Back()
			delete(c.cache, last.Value.(*entry).key)
			c.ll.Remove(last)
		}
		elem := c.ll.PushFront(&entry{key, value})
		c.cache[key] = elem
	}
}

func main() {
	cache := NewLRUCache(3)

	cache.Put("key1", "value1")
	cache.Put("key2", "value2")
	cache.Put("key3", "value3")

	fmt.Println(cache.Get("key1")) // 输出: value1
	cache.Put("key4", "value4")   // 移除 key2
	fmt.Println(cache.Get("key2")) // 输出: false
	fmt.Println(cache.Get("key3")) // 输出: value3
	fmt.Println(cache.Get("key4")) // 输出: value4
}

在这个示例中，我们定义了一个LRUCache结构体，它包含一个容量（capacity）、一个缓存（cache，使用map[string]*list.Element实现）、一个双向链表（ll）和一个互斥锁（mu）。我们还定义了一个entry结构体来存储键值对。

NewLRUCache函数用于创建一个新的LRUCache实例。Get方法用于获取缓存中的值，如果存在则将其移动到链表的前端。Put方法用于向缓存中添加或更新键值对，如果缓存已满，则移除链表尾部的元素。

这个示例展示了如何实现一个简单的LRU缓存系统。在实际应用中，你可能需要根据需求对这个实现进行扩展和优化。