Πώς υλοποιήθηκε η προσωρινή αποθήκευση δεδομένων; Ποια πολιτική cache χρησιμοποιήθηκε;

Η προσωρινή αποθήκευση δεδομένων υλοποιείται συνήθως με μια δομή δεδομένων που αποθηκεύει πρόσφατα ή συχνά χρησιμοποιούμενα αντικείμενα για γρήγορη πρόσβαση.

Η πολιτική cache εξαρτάται από το έργο, αλλά συχνά χρησιμοποιούνται:

• LRU (Least Recently Used) — διαγράφουν τα λιγότερο πρόσφατα χρησιμοποιούμενα στοιχεία.
• LFU (Least Frequently Used) — διαγράφουν τα λιγότερο συχνά χρησιμοποιούμενα.
• TTL (Time To Live) — τα στοιχεία διαγράφονται μετά από ορισμένο χρόνο.

Στο Go, για την cache, μπορεί να χρησιμοποιηθεί ένα χάρτης με πρόσθετη λογική για την πολιτική διαγραφής ή έτοιμα βιβλιοθήκες (π.χ., groupcache ή ristretto).

Παράδειγμα απλής LRU cache με χρήση λίστας:

import (
    "container/list"
    "sync"
)

type CacheItem struct {
    key   string
    value interface{}
}

type LRUCache struct {
    capacity int
    cache    map[string]*list.Element
    list     *list.List
    mu       sync.Mutex
}

func NewLRUCache(cap int) *LRUCache {
    return &LRUCache{
        capacity: cap,
        cache:    make(map[string]*list.Element),
        list:     list.New(),
    }
}

func (c *LRUCache) Get(key string) (interface{}, bool) {
    c.mu.Lock()
    defer c.mu.Unlock()

    if elem, ok := c.cache[key]; ok {
        c.list.MoveToFront(elem)
        return elem.Value.(*CacheItem).value, true
    }
    return nil, false
}

func (c *LRUCache) Put(key string, value interface{}) {
    c.mu.Lock()
    defer c.mu.Unlock()

    if elem, ok := c.cache[key]; ok {
        c.list.MoveToFront(elem)
        elem.Value.(*CacheItem).value = value
        return
    }

    if c.list.Len() == c.capacity {
        back := c.list.Back()
        if back != nil {
            c.list.Remove(back)
            delete(c.cache, back.Value.(*CacheItem).key)
        }
    }

    item := &CacheItem{key, value}
    elem := c.list.PushFront(item)
    c.cache[key] = elem
}