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语言实现一个基本的缓存系统，并结合随机过期时间和分布式锁来预防缓存雪崩。