Go中HashMap緩存的讀寫并發優化

在Go語言中，可以使用sync.Map來實現一個線程安全的HashMap緩存。sync.Map是Go標準庫提供的一個并發安全的map類型，它在內部實現了高效的讀寫操作，適用于讀多寫少的場景。

下面是一個使用sync.Map實現的簡單緩存示例：

package main

import (
	"fmt"
	"sync"
)

type Cache struct {
	data sync.Map
}

func (c *Cache) Get(key interface{}) (interface{}, bool) {
	value, ok := c.data.Load(key)
	return value, ok
}

func (c *Cache) Set(key, value interface{}) {
	c.data.Store(key, value)
}

func main() {
	cache := &Cache{}

	// 寫入緩存
	cache.Set("key1", "value1")
	cache.Set("key2", "value2")

	// 讀取緩存
	if value, ok := cache.Get("key1"); ok {
		fmt.Println("key1:", value)
	} else {
		fmt.Println("key1 not found")
	}

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

然而，sync.Map并不適用于所有場景。在某些情況下，你可能需要更細粒度的控制，例如設置過期時間、最大容量等。這時，你可以使用第三方庫，如groupcache或bigcache，它們提供了更豐富的功能。

groupcache是一個基于內存的分布式緩存庫，它支持緩存失效、最大容量等功能。下面是一個使用groupcache實現的簡單緩存示例：

package main

import (
	"fmt"
	"github.com/golang/groupcache"
)

type Cache struct {
	groupcache.Group
}

func NewCache() *Cache {
	c := groupcache.NewGroup("my-group", groupcache.SingleServer(groupcache.NewFileStore("cache")))
	return &Cache{Group: c}
}

func (c *Cache) Get(key string) (interface{}, error) {
	value, err := c.Group.Get(key)
	if err != nil {
		return nil, err
	}
	return value, nil
}

func (c *Cache) Set(key string, value interface{}) error {
	return c.Group.Set(key, value)
}

func main() {
	cache := NewCache()

	// 寫入緩存
	err := cache.Set("key1", "value1")
	if err != nil {
		fmt.Println("Error setting key1:", err)
		return
	}

	err = cache.Set("key2", "value2")
	if err != nil {
		fmt.Println("Error setting key2:", err)
		return
	}

	// 讀取緩存
	value, err := cache.Get("key1")
	if err != nil {
		fmt.Println("Error getting key1:", err)
		return
	}
	fmt.Println("key1:", value)

	value, err = cache.Get("key2")
	if err != nil {
		fmt.Println("Error getting key2:", err)
		return
	}
	fmt.Println("key2:", value)
}

在這個示例中，我們使用了groupcache庫來實現一個簡單的緩存。groupcache支持多種存儲后端，如內存、文件系統等。你可以根據需要選擇合適的存儲后端。