Go HashMap缓存的清理与维护

Go中的HashMap缓存可以通过以下方法进行清理和维护：

1. 设置过期时间：为HashMap中的每个键值对设置一个过期时间，当超过这个时间时，自动清除该键值对。可以使用time.AfterFunc函数来实现这个功能。

package main

import (
	"fmt"
	"time"
)

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

type HashMapCache struct {
	items map[string]CacheItem
}

func NewHashMapCache() *HashMapCache {
	return &HashMapCache{
		items: make(map[string]CacheItem),
	}
}

func (c *HashMapCache) Set(key string, value interface{}, duration time.Duration) {
	expireTime := time.Now().Add(duration)
	c.items[key] = CacheItem{
		Value:      value,
		ExpireTime: expireTime,
	}
}

func (c *HashMapCache) Get(key string) (interface{}, bool) {
	item, ok := c.items[key]
	if !ok || time.Now().After(item.ExpireTime) {
		return nil, false
	}
	return item.Value, true
}

func (c *HashMapCache) Remove(key string) {
	delete(c.items, key)
}

func (c *HashMapCache) Clear() {
	c.items = make(map[string]CacheItem)
}

func main() {
	cache := NewHashMapCache()
	cache.Set("key1", "value1", 5*time.Second)
	cache.Set("key2", "value2", 10*time.Second)

	if value, ok := cache.Get("key1"); ok {
		fmt.Println("key1:", value)
	} else {
		fmt.Println("key1 not found or expired")
	}

	time.Sleep(6 * time.Second)

	if value, ok := cache.Get("key1"); ok {
		fmt.Println("key1:", value)
	} else {
		fmt.Println("key1 not found or expired")
	}

	cache.Remove("key1")

	if value, ok := cache.Get("key1"); ok {
		fmt.Println("key1:", value)
	} else {
		fmt.Println("key1 not found or expired")
	}
}

2. 使用定时器：可以设置一个定时器，定期检查HashMap中的键值对是否已经过期，如果过期则清除。可以使用time.Ticker来实现这个功能。

package main

import (
	"fmt"
	"time"
)

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

type HashMapCache struct {
	items map[string]CacheItem
}

func NewHashMapCache() *HashMapCache {
	return &HashMapCache{
		items: make(map[string]CacheItem),
	}
}

func (c *HashMapCache) Set(key string, value interface{}, duration time.Duration) {
	expireTime := time.Now().Add(duration)
	c.items[key] = CacheItem{
		Value:      value,
		ExpireTime: expireTime,
	}
}

func (c *HashMapCache) Get(key string) (interface{}, bool) {
	item, ok := c.items[key]
	if !ok || time.Now().After(item.ExpireTime) {
		return nil, false
	}
	return item.Value, true
}

func (c *HashMapCache) Remove(key string) {
	delete(c.items, key)
}

func (c *HashMapCache) Clear() {
	c.items = make(map[string]CacheItem)
}

func (c *HashMapCache) StartCleanupTimer(duration time.Duration) {
	ticker := time.NewTicker(duration)
	go func() {
		for range ticker.C {
			c.Cleanup()
		}
	}()
}

func (c *HashMapCache) Cleanup() {
	now := time.Now()
	for key, item := range c.items {
		if now.After(item.ExpireTime) {
			c.Remove(key)
		}
	}
}

func main() {
	cache := NewHashMapCache()
	cache.Set("key1", "value1", 5*time.Second)
	cache.Set("key2", "value2", 10*time.Second)

	cache.StartCleanupTimer(2 * time.Second)

	time.Sleep(10 * time.Second)
	cache.StopCleanupTimer()
}

3. 内存限制：当HashMap占用的内存达到一定阈值时，可以自动清除部分过期或不再使用的键值对。可以使用sync.Pool来实现这个功能。

package main

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

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

type HashMapCache struct {
	items map[string]*list.Element
	evict  *list.List
}

func NewHashMapCache(maxSize int) *HashMapCache {
	return &HashMapCache{
		items: make(map[string]*list.Element),
		evict:  list.New(),
		maxSize: maxSize,
	}
}

func (c *HashMapCache) Set(key string, value interface{}, duration time.Duration) {
	if elem, ok := c.items[key]; ok {
		c.evict.MoveToFront(elem)
		elem.Value.(*CacheItem).Value = value
		elem.Value.(*CacheItem).ExpireTime = time.Now().Add(duration)
		return
	}

	if c.evict.Len() >= c.maxSize {
		lastElem := c.evict.Back()
		c.removeItem(lastElem)
	}

	item := &CacheItem{
		Value:      value,
		ExpireTime: time.Now().Add(duration),
	}

	elem := c.evict.PushFront(item)
	c.items[key] = elem
}

func (c *HashMapCache) Get(key string) (interface{}, bool) {
	if elem, ok := c.items[key]; ok {
		if time.Now().After(elem.Value.(*CacheItem).ExpireTime) {
			c.removeItem(elem)
			return nil, false
		}
		c.evict.MoveToFront(elem)
		return elem.Value.(*CacheItem).Value, true
	}
	return nil, false
}

func (c *HashMapCache) Remove(elem *list.Element) {
	delete(c.items, elem.Value.(*CacheItem).Key)
	c.evict.Remove(elem)
}

func (c *HashMapCache) Clear() {
	c.items = make(map[string]*list.Element)
	c.evict = list.New()
}

func main() {
	cache := NewHashMapCache(2)
	cache.Set("key1", "value1", 5*time.Second)
	cache.Set("key2", "value2", 10*time.Second)

	time.Sleep(6 * time.Second)
	cache.Set("key3", "value3", 15*time.Second)

	if value, ok := cache.Get("key1"); ok {
		fmt.Println("key1:", value)
	} else {
		fmt.Println("key1 not found or expired")
	}

	if value, ok := cache.Get("key2"); ok {
		fmt.Println("key2:", value)
	} else {
		fmt.Println("key2 not found or expired")
	}

	if value, ok := cache.Get("key3"); ok {
		fmt.Println("key3:", value)
	} else {
		fmt.Println("key3 not found or expired")
	}
}

这些方法可以根据实际需求进行组合使用，以实现更高效的缓存清理和维护。