分布式缓存实践：Go HashMap的缓存数据聚合

在分布式系统中，缓存是一种提高性能和响应速度的重要手段。Go语言中的sync.Map是一个内置的并发安全的map实现，适合用于缓存数据聚合。下面是一个使用sync.Map实现分布式缓存的示例代码：

package main

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

// CacheItem 是缓存项的结构体
type CacheItem struct {
	Key        string
	Value      interface{}
	Expiration time.Time
}

// DistributedCache 是分布式缓存的实现
type DistributedCache struct {
	cache sync.Map
}

// NewDistributedCache 创建一个新的分布式缓存实例
func NewDistributedCache() *DistributedCache {
	return &DistributedCache{}
}

// Set 将键值对存储到缓存中，并设置过期时间
func (dc *DistributedCache) Set(key string, value interface{}, ttl time.Duration) {
	expiration := time.Now().Add(ttl).Unix()
	dc.cache.Store(key, &CacheItem{
		Key:        key,
		Value:      value,
		Expiration: expiration,
	})
}

// Get 从缓存中获取键对应的值
func (dc *DistributedCache) Get(key string) (interface{}, bool) {
	item, found := dc.cache.Load(key)
	if !found {
		return nil, false
	}

	cacheItem := item.(*CacheItem)
	if time.Now().Unix() > cacheItem.Expiration {
		dc.cache.Delete(key)
		return nil, false
	}

	return cacheItem.Value, true
}

func main() {
	cache := NewDistributedCache()

	// 设置缓存项
	cache.Set("key1", "value1", 5*time.Second)
	cache.Set("key2", "value2", 10*time.Second)

	// 获取缓存项
	if value, found := cache.Get("key1"); found {
		fmt.Println("key1:", value)
	} else {
		fmt.Println("key1 not found")
	}

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

	// 等待缓存项过期
	time.Sleep(6 * time.Second)

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

在这个示例中，我们定义了一个DistributedCache结构体，它包含一个sync.Map类型的字段cache。Set方法用于将键值对存储到缓存中，并设置过期时间。Get方法用于从缓存中获取键对应的值，如果键存在且未过期，则返回对应的值，否则返回nil。

在main函数中，我们创建了一个DistributedCache实例，并设置了一些缓存项。然后我们尝试获取这些缓存项，并打印它们的值。最后，我们等待一段时间，让缓存项过期，再次尝试获取它们，这次它们应该已经被删除。