分布式緩存實踐：Go HashMap的緩存數據訪問緩存淘汰算法

在分布式系統中，緩存是一種提高數據訪問速度的有效手段。Go語言中的sync.Map是一個內置的并發安全的map，可以用來實現分布式緩存。為了實現緩存淘汰算法，我們可以使用以下幾種策略：

1. LRU（Least Recently Used）：最近最少使用的數據將被淘汰。這種策略可以通過維護一個雙向鏈表來實現，鏈表中存儲了緩存的鍵值對。當緩存滿時，從鏈表頭部移除元素。訪問緩存時，將對應的鍵值對移動到鏈表尾部。

type LRUCache struct {
    capacity int
    cache    sync.Map
    lruList  *list.List
}

type entry struct {
    key   string
    value interface{}
    index int
}

func NewLRUCache(capacity int) *LRUCache {
    return &LRUCache{
        capacity: capacity,
        lruList:  list.New(),
    }
}

func (c *LRUCache) Get(key string) (interface{}, bool) {
    if value, ok := c.cache.Load(key); ok {
        c.lruList.MoveToFront(c.lruList.Find(key))
        return value, true
    }
    return nil, false
}

func (c *LRUCache) Put(key string, value interface{}) {
    if c.capacity <= 0 {
        return
    }

    if value, ok := c.cache.LoadOrStore(key, value); ok {
        c.lruList.MoveToFront(c.lruList.Find(key))
    } else {
        if c.lruList.Len() >= c.capacity {
            last := c.lruList.Back()
            delete(c.cache, last.Value.(*entry).key)
            c.lruList.Remove(last)
        }
        newEntry := &entry{key: key, value: value}
        c.lruList.PushFront(newEntry)
        c.cache.Store(key, newEntry)
    }
}

2. TTL（Time To Live）：數據在一定時間內有效，過期將被淘汰。這種策略可以通過為每個緩存項設置一個過期時間來實現。當訪問緩存時，檢查是否已過期，如果過期則淘汰。

type TTLCache struct {
    capacity int
    cache    sync.Map
    ttlMap   map[string]int64
}

func NewTTLCache(capacity int) *TTLCache {
    return &TTLCache{
        capacity: capacity,
        ttlMap:   make(map[string]int64),
    }
}

func (c *TTLCache) Get(key string) (interface{}, bool) {
    if value, ok := c.cache.Load(key); ok {
        if time.Since(time.Unix(value.(*entry).expiration, 0)) <= time.Duration(value.(*entry).ttl)*time.Second {
            c.cache.Store(key, value)
            c.lruList.MoveToFront(c.lruList.Find(key))
            return value, true
        }
    }
    return nil, false
}

func (c *TTLCache) Put(key string, value interface{}, ttl int) {
    if c.capacity <= 0 {
        return
    }

    expiration := time.Now().Add(time.Duration(ttl) * time.Second).Unix()
    if value, ok := c.cache.LoadOrStore(key, &entry{value: value, expiration: expiration}); ok {
        c.lruList.MoveToFront(c.lruList.Find(key))
    } else {
        if c.lruList.Len() >= c.capacity {
            last := c.lruList.Back()
            delete(c.cache, last.Value.(*entry).key)
            c.lruList.Remove(last)
        }
        newEntry := &entry{value: value, expiration: expiration}
        c.lruList.PushFront(newEntry)
        c.cache.Store(key, newEntry)
    }
    c.ttlMap[key] = expiration
}

3. LFU（Least Frequently Used）：最不經常使用的數據將被淘汰。這種策略可以通過維護一個哈希表來記錄每個鍵值對的出現頻率來實現。當緩存滿時，根據頻率從低到高淘汰數據。

type LFUCache struct {
    capacity int
    cache    sync.Map
    freqMap  map[string]int
    minFreq  int
}

func NewLFUCache(capacity int) *LFUCache {
    return &LFUCache{
        capacity: capacity,
        freqMap:  make(map[string]int),
        minFreq:  0,
    }
}

func (c *LFUCache) Get(key string) (interface{}, bool) {
    if value, ok := c.cache.Load(key); ok {
        c.increaseFreq(key)
        return value, true
    }
    return nil, false
}

func (c *LFUCache) Put(key string, value interface{}) {
    if c.capacity <= 0 {
        return
    }

    if _, ok := c.cache.Load(key); ok {
        c.cache.Store(key, value)
        c.increaseFreq(key)
    } else {
        if c.cache.Len() >= c.capacity {
            minFreqKey := ""
            minFreq := int(^uint(0) >> 1) // Max int value
            for k, v := range c.freqMap {
                if v < minFreq {
                    minFreq = v
                    minFreqKey = k
                }
            }
            delete(c.cache, minFreqKey)
            delete(c.freqMap, minFreqKey)
        }
        c.cache.Store(key, value)
        c.freqMap[key] = 1
        if c.minFreq == 0 {
            c.minFreq = 1
        }
    }
}

func (c *LFUCache) increaseFreq(key string) {
    freq := c.freqMap[key]
    delete(c.freqMap, key)
    c.freqMap[key] = freq + 1
    if freq == c.minFreq {
        c.minFreq++
    }
}

這些緩存淘汰算法可以根據具體需求進行選擇和實現。在實際應用中，還可以根據業務特點對緩存策略進行調整和優化。