Go HashMap緩存的并發讀寫控制

在Go語言中，sync.Map 是一個內置的并發安全的map類型，它可以在多個goroutine之間安全地共享數據。但是，如果你需要更高級的緩存策略，比如設置過期時間或者更復雜的讀寫控制，你可能需要使用第三方庫或者自己實現一個并發安全的緩存系統。

以下是一個簡單的例子，展示了如何使用 sync.Map 來實現一個基本的緩存系統，并且包含了一個簡單的讀寫鎖來控制并發訪問：

package main

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

type CacheItem struct {
	Value      interface{}
	ExpireAt   int64       // 過期時間戳
	AccessTime int64       // 訪問時間戳
}

type ConcurrentCache struct {
	mu         sync.RWMutex
	items      map[string]CacheItem
}

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

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

func (c *ConcurrentCache) Set(key string, value interface{}, ttl time.Duration) {
	c.mu.Lock()
	defer c.mu.Unlock()
	expiration := time.Now().Add(ttl).Unix()
	c.items[key] = CacheItem{
		Value:      value,
		ExpireAt:   expiration,
		AccessTime: time.Now().Unix(),
	}
}

func (c *ConcurrentCache) Delete(key string) {
	c.mu.Lock()
	defer c.mu.Unlock()
	delete(c.items, key)
}

func main() {
	cache := NewConcurrentCache()

	// 設置一個鍵值對，有效期為5秒
	cache.Set("mykey", "myvalue", 5*time.Second)

	// 讀取鍵值對
	if value, ok := cache.Get("mykey"); ok {
		fmt.Println("Value:", value)
	} else {
		fmt.Println("Key not found or expired")
	}

	// 等待5秒，鍵值對應該已經過期
	time.Sleep(6 * time.Second)

	// 再次嘗試讀取鍵值對，應該返回false
	if value, ok := cache.Get("mykey"); ok {
		fmt.Println("Value:", value)
	} else {
		fmt.Println("Key not found or expired")
	}
}

在這個例子中，我們定義了一個 ConcurrentCache 結構體，它包含了一個 sync.RWMutex 來控制并發讀寫，以及一個 map[string]CacheItem 來存儲緩存項。CacheItem 結構體包含了值、過期時間和訪問時間。

Get 方法用于讀取緩存項，如果鍵存在且未過期，則更新訪問時間并返回值。Set 方法用于設置緩存項，包括過期時間。Delete 方法用于刪除緩存項。

請注意，這個例子中的緩存沒有持久化存儲，它只在內存中存儲數據。如果你需要一個持久化的緩存系統，你可能需要使用數據庫或者其他存儲介質來存儲緩存數據，并且需要考慮數據的一致性和恢復問題。