Go緩存設計：HashMap與緩存雪崩預防

在Go語言中，設計一個高效的緩存系統是一個常見的任務。緩存可以顯著提高應用程序的性能，特別是在處理大量數據和高并發請求時。下面是一個使用Go語言實現的緩存系統示例，結合了HashMap和緩存雪崩預防策略。

1. 基本緩存系統設計

首先，我們定義一個基本的緩存結構體，使用sync.Map來存儲鍵值對。sync.Map是Go語言提供的線程安全的map類型，適合在并發環境中使用。

package main

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

type Cache struct {
	store sync.Map
}

func NewCache() *Cache {
	return &Cache{}
}

func (c *Cache) Get(key interface{}) (interface{}, bool) {
	value, ok := c.store.Load(key)
	if !ok {
		return nil, false
	}
	return value, true
}

func (c *Cache) Set(key, value interface{}, ttl time.Duration) {
	c.store.Store(key, value)
}

func (c *Cache) Delete(key interface{}) {
	c.store.Delete(key)
}

2. 緩存雪崩預防策略

緩存雪崩是指緩存中大量數據在同一時間過期，導致大量請求同時訪問數據庫或其他存儲系統，從而引發性能問題。為了預防緩存雪崩，我們可以采取以下策略：

2.1 隨機過期時間

為每個緩存的過期時間添加隨機值，使得不同鍵的過期時間不會集中在同一時刻。

import (
	"math/rand"
	"time"
)

func randomTTL() time.Duration {
	min := time.Minute
	max := 5 * time.Minute
	return min + time.Duration(rand.Intn(int(max-min)))
}

func (c *Cache) SetWithRandomTTL(key, value interface{}, baseTTL time.Duration) {
	ttl := randomTTL() + baseTTL
	c.store.Store(key, value)
}

2.2 分布式鎖

在分布式系統中，可以使用分布式鎖來確保同一時間只有一個節點可以設置緩存過期時間。這可以通過Redis等分布式鎖解決方案來實現。

import (
	"github.com/go-redis/redis/v8"
	"context"
	"time"
)

var ctx = context.Background()

type RedisLock struct {
	client *redis.Client
}

func NewRedisLock(client *redis.Client) *RedisLock {
	return &RedisLock{client: client}
}

func (l *RedisLock) Lock(key string) error {
	return l.client.SetNX(ctx, key, "locked", 10*time.Second).Err()
}

func (l *RedisLock) Unlock(key string) error {
	script := `
	if redis.call("get", KEYS[1]) == ARGV[1] then
		return redis.call("del", KEYS[1])
	else
		return 0
	end
	`
	_, err := l.client.Eval(ctx, script, []string{key}, "locked").Result()
	return err
}

3. 完整示例

結合上述策略，我們可以實現一個完整的緩存系統示例：

package main

import (
	"fmt"
	"math/rand"
	"sync"
	"time"

	"github.com/go-redis/redis/v8"
)

var ctx = context.Background()

type Cache struct {
	store sync.Map
}

func NewCache() *Cache {
	return &Cache{}
}

func (c *Cache) Get(key interface{}) (interface{}, bool) {
	value, ok := c.store.Load(key)
	if !ok {
		return nil, false
	}
	return value, true
}

func (c *Cache) Set(key, value interface{}, ttl time.Duration) {
	c.store.Store(key, value)
}

func (c *Cache) Delete(key interface{}) {
	c.store.Delete(key)
}

type RedisLock struct {
	client *redis.Client
}

func NewRedisLock(client *redis.Client) *RedisLock {
	return &RedisLock{client: client}
}

func (l *RedisLock) Lock(key string) error {
	return l.client.SetNX(ctx, key, "locked", 10*time.Second).Err()
}

func (l *RedisLock) Unlock(key string) error {
	script := `
	if redis.call("get", KEYS[1]) == ARGV[1] then
		return redis.call("del", KEYS[1])
	else
		return 0
	end
	`
	_, err := l.client.Eval(ctx, script, []string{key}, "locked").Result()
	return err
}

func main() {
	cache := NewCache()
	redisClient := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "", // no password set
		DB:       0,  // use default DB
	})

	lock := NewRedisLock(redisClient)

	// Set cache with random TTL
	cache.SetWithRandomTTL("key1", "value1", 10*time.Minute)

	// Simulate a request to get the cache value
	value, ok := cache.Get("key1")
	if ok {
		fmt.Println("Cache hit:", value)
	} else {
		fmt.Println("Cache miss")
	}

	// Simulate a request to set a new cache value with random TTL
	cache.SetWithRandomTTL("key2", "value2", 10*time.Minute)

	// Simulate a request to get the cache value
	value, ok = cache.Get("key2")
	if ok {
		fmt.Println("Cache hit:", value)
	} else {
		fmt.Println("Cache miss")
	}
}

這個示例展示了如何使用Go語言實現一個基本的緩存系統，并結合隨機過期時間和分布式鎖來預防緩存雪崩。