高效Go緩存：HashMap與緩存數據過期自動清理

在Go語言中，實現高效的緩存系統通常需要考慮以下幾個方面：

1. 緩存存儲：可以使用map來實現簡單的鍵值對存儲。
2. 緩存過期：需要一種機制來自動清理過期的緩存數據。
3. 并發安全：在高并發環境下，需要確保緩存的讀寫操作是線程安全的。

下面是一個簡單的示例，展示了如何使用map來實現一個帶有過期功能的緩存系統：

package main

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

// CacheItem 表示緩存項
type CacheItem struct {
	key         string
	value       interface{}
	expiration time.Time
}

// LRUCache 是一個簡單的LRU緩存實現
type LRUCache struct {
	capacity int
	cache    map[string]*list.Element
	evictList *list.List
	mu        sync.Mutex
}

// NewLRUCache 創建一個新的LRU緩存
func NewLRUCache(capacity int) *LRUCache {
	return &LRUCache{
		capacity: capacity,
		cache:    make(map[string]*list.Element),
		evictList: list.New(),
	}
}

// Add 添加一個新的緩存項
func (c *LRUCache) Add(key string, value interface{}, ttl time.Duration) {
	c.mu.Lock()
	defer c.mu.Unlock()

	if elem, exists := c.cache[key]; exists {
		c.evictList.MoveToFront(elem)
		elem.Value.(*CacheItem).value = value
		elem.Value.(*CacheItem).expiration = time.Now().Add(ttl)
		return
	}

	if c.evictList.Len() >= c.capacity {
		lastElem := c.evictList.Back()
		delete(c.cache, lastElem.Value.(*CacheItem).key)
		c.evictList.Remove(lastElem)
	}

	item := &CacheItem{
		key:         key,
		value:       value,
		expiration: time.Now().Add(ttl),
	}

	elem := c.evictList.PushFront(item)
	c.cache[key] = elem
}

// Get 獲取緩存項，如果不存在則返回nil
func (c *LRUCache) Get(key string) interface{} {
	c.mu.Lock()
	defer c.mu.Unlock()

	if elem, exists := c.cache[key]; exists {
		item := elem.Value.(*CacheItem)
		if time.Now().Before(item.expiration) {
			c.evictList.MoveToFront(elem)
			return item.value
		}
		c.removeElement(elem)
	}
	return nil
}

// removeElement 從鏈表和緩存中移除元素
func (c *LRUCache) removeElement(elem *list.Element) {
	c.evictList.Remove(elem)
	delete(c.cache, elem.Value.(*CacheItem).key)
}

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

	cache.Add("key1", "value1", 5*time.Second)
	cache.Add("key2", "value2", 10*time.Second)

	fmt.Println(cache.Get("key1")) // 輸出: value1

	time.Sleep(6 * time.Second)

	fmt.Println(cache.Get("key1")) // 輸出: nil，因為key1已經過期

	cache.Add("key3", "value3", 5*time.Second)

	fmt.Println(cache.Get("key2")) // 輸出: nil，因為key2已經被移除
	fmt.Println(cache.Get("key3")) // 輸出: value3
}

解釋

1. CacheItem：表示緩存項，包含鍵、值和過期時間。
2. LRUCache：實現LRU緩存的結構體，包含容量、緩存映射、過期列表和互斥鎖。
3. NewLRUCache：創建一個新的LRU緩存實例。
4. Add：添加一個新的緩存項，如果緩存已滿則移除最久未使用的項。
5. Get：獲取緩存項，如果存在且未過期則返回值，否則返回nil。
6. removeElement：從鏈表和緩存中移除元素。

這個示例展示了如何使用map和雙向鏈表來實現一個簡單的LRU緩存，并且具備自動清理過期數據的能力。在高并發環境下，可以考慮使用sync.RWMutex來進一步優化讀寫性能。