實戰Go：HashMap緩存的緩存數據訪問緩存失效處理

在Go中，使用sync.Map作為HashMap緩存時，可能會遇到緩存失效的問題。為了解決這個問題，我們可以采用以下策略：

1. 設置緩存過期時間：為每個緩存項設置一個過期時間，當過期時間到達時，自動刪除該緩存項。可以使用time.AfterFunc函數來實現定時器功能。

package main

import (
	"fmt"
	"sync"
	"time"
)

type CacheItem struct {
	Value      interface{}
	ExpireTime time.Time
}

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

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

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

	item, ok := c.cache[key]
	if !ok || item.ExpireTime.Before(time.Now()) {
		return nil, false
	}

	c.evictList.MoveToFront(item.Value.(*list.Element))
	return item.Value, true
}

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

	if item, ok := c.cache[key]; ok {
		c.evictList.Remove(item.Value.(*list.Element))
		delete(c.cache, key)
	} else if len(c.cache) >= c.capacity {
		lastElem := c.evictList.Back()
		delete(c.cache, lastElem.Value.(*CacheItem).Key)
		c.evictList.Remove(lastElem)
	}

	item := &CacheItem{
		Value:      value,
		ExpireTime: time.Now().Add(ttl),
	}
	itemValue := item.Value
	element := c.evictList.PushFront(itemValue)
	c.cache[key] = *item
}

func main() {
	cache := NewLRUCache(2)
	cache.Put("key1", "value1", 5*time.Second)
	cache.Put("key2", "value2", 5*time.Second)
	fmt.Println(cache.Get("key1")) // 輸出: value1 true

	time.Sleep(6 * time.Second)
	fmt.Println(cache.Get("key1")) // 輸出: <nil> false
}

2. 使用定時任務清理過期緩存：可以使用time.Ticker來定期檢查緩存中的過期項，并將其刪除。

package main

import (
	"fmt"
	"sync"
	"time"
)

type CacheItem struct {
	Value      interface{}
	ExpireTime time.Time
}

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

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

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

	item, ok := c.cache[key]
	if !ok || item.ExpireTime.Before(time.Now()) {
		return nil, false
	}

	c.evictList.MoveToFront(item.Value.(*list.Element))
	return item.Value, true
}

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

	if item, ok := c.cache[key]; ok {
		c.evictList.Remove(item.Value.(*list.Element))
		delete(c.cache, key)
	} else if len(c.cache) >= c.capacity {
		lastElem := c.evictList.Back()
		delete(c.cache, lastElem.Value.(*CacheItem).Key)
		c.evictList.Remove(lastElem)
	}

	item := &CacheItem{
		Value:      value,
		ExpireTime: time.Now().Add(ttl),
	}
	itemValue := item.Value
	element := c.evictList.PushFront(itemValue)
	c.cache[key] = *item
}

func (c *LRUCache) StartEviction(interval time.Duration) {
	ticker := time.NewTicker(interval)
	go func() {
		for range ticker.C {
			c.mu.Lock()
			now := time.Now()
			for _, item := range c.cache {
				if item.ExpireTime.Before(now) {
					c.evictList.Remove(item.Value.(*list.Element))
					delete(c.cache, item.Key)
				}
			}
			c.mu.Unlock()
		}
	}()
}

func main() {
	cache := NewLRUCache(2)
	cache.Put("key1", "value1", 5*time.Second)
	cache.Put("key2", "value2", 5*time.Second)
	fmt.Println(cache.Get("key1")) // 輸出: value1 true

	cache.StartEviction(1 * time.Second)

	time.Sleep(6 * time.Second)
	fmt.Println(cache.Get("key1")) // 輸出: <nil> false
}

這兩種策略可以結合使用，以實現更高效的緩存失效處理。