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緩存系統。在實際應用中，你可能需要根據需求對這個實現進行擴展和優化。