实战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
}

这两种策略可以结合使用，以实现更高效的缓存失效处理。