Go緩存設計：HashMap與緩存隔離策略

在Go語言中設計緩存時，HashMap是一個常見的選擇，因為它提供了快速的鍵值對存儲。然而，當涉及到緩存隔離策略時，需要考慮多個方面，包括緩存的大小限制、緩存項的過期時間、緩存穿透、緩存雪崩等問題。以下是一個綜合考慮這些因素的緩存設計方案：

1. 使用HashMap存儲緩存

首先，我們使用一個HashMap來存儲緩存項。為了簡化示例，我們假設每個緩存項都有一個唯一的鍵和一個值。

package main

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

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

type Cache struct {
	mu         sync.RWMutex
	items      map[string]CacheItem
	maxSize    int
}

func NewCache(maxSize int) *Cache {
	return &Cache{
		items:      make(map[string]CacheItem),
		maxSize:    maxSize,
	}
}

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

func (c *Cache) Set(key string, value interface{}, ttl time.Duration) {
	c.mu.Lock()
	defer c.mu.Unlock()
	if len(c.items) >= c.maxSize {
		c.evict()
	}
	c.items[key] = CacheItem{
		Value:      value,
		ExpireTime: time.Now().Add(ttl),
	}
}

func (c *Cache) evict() {
	// Simple eviction by removing the first item inserted
	for key := range c.items {
		delete(c.items, key)
		break
	}
}

func main() {
	cache := NewCache(10)
	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")
	}
}

2. 緩存隔離策略

2.1 緩存大小限制

在上面的示例中，我們通過maxSize字段限制了緩存的大小。當緩存達到最大大小時，會觸發evict方法刪除最早的緩存項。

2.2 緩存項的過期時間

每個緩存項都有一個ExpireTime字段，用于存儲該緩存項的過期時間。在Get方法中，我們檢查當前時間是否超過了緩存項的過期時間，如果是，則返回false。

2.3 緩存穿透

緩存穿透是指查詢一個不存在的數據，由于緩存中也不存在這個數據，所以每次請求都會直接查詢數據庫。為了避免緩存穿透，可以在Set方法中添加一個簡單的布隆過濾器（Bloom Filter）來檢查鍵是否存在。

import "github.com/google/uuid"

func (c *Cache) Set(key string, value interface{}, ttl time.Duration) {
	c.mu.Lock()
	defer c.mu.Unlock()
	if len(c.items) >= c.maxSize {
		c.evict()
	}
	if !c.hasKey(key) {
		key = uuid.New().String() // Generate a unique key if the original key is not provided
	}
	c.items[key] = CacheItem{
		Value:      value,
		ExpireTime: time.Now().Add(ttl),
	}
}

func (c *Cache) hasKey(key string) bool {
	_, exists := c.items[key]
	return exists
}

2.4 緩存雪崩

緩存雪崩是指緩存中大量緩存項在同一時間過期，導致大量請求直接查詢數據庫。為了避免緩存雪崩，可以為每個緩存項設置一個隨機過期時間。

import (
	"math/rand"
	"time"
)

func (c *Cache) Set(key string, value interface{}, ttl time.Duration) {
	c.mu.Lock()
	defer c.mu.Unlock()
	if len(c.items) >= c.maxSize {
		c.evict()
	}
	if !c.hasKey(key) {
		key = uuid.New().String() // Generate a unique key if the original key is not provided
	}
	expiration := time.Now().Add(ttl - time.Duration(rand.Intn(int(ttl/10))))
	c.items[key] = CacheItem{
		Value:      value,
		ExpireTime: expiration,
	}
}

通過以上設計，我們可以實現一個具有緩存大小限制、緩存項過期時間、緩存穿透防護和緩存雪崩防護的緩存系統。