Как мне настроить освобождаемый кеш в Golang (т. е. я могу освободить память при обнаружении нехватки памяти)?

В этом ответе есть решение для выделения памяти во время выполнения.

Вот отправная точка для параллельного безопасного кеша с использованием этого кода:

package main

import (
    "bufio"
    "os"
    "strconv"
    "strings"
    "sync"
)

type Memory struct {
    MemTotal     int
    MemFree      int
    MemAvailable int
}

type Cache[T any] struct {
    MinMemFree int // Min number of free bytes
    chunkSize  int // Number of key/value pairs removed from data when MinMemFree is reached
    mu         sync.Mutex
    data       map[string]T
    order      []string // Keeps track of the order of keys added to data
}

func NewCache[T any](minMemFree int, chunkSize int) *Cache[T] {
    return &Cache[T]{
        MinMemFree: minMemFree,
        chunkSize:  chunkSize,
        data:       make(map[string]T),
        order:      []string{},
    }
}

func (c *Cache[T]) Get(key string) T {
    c.mu.Lock()
    defer c.mu.Unlock()

    return c.data[key]
}

func (c *Cache[T]) Set(key string, value T) int {
    c.mu.Lock()
    defer c.mu.Unlock()

    c.data[key] = value
    c.order = append(c.order, key)

    if c.minSizeReached() {
        return c.freeOldestChunk()
    }
    return 0
}

// Free oldest items in the cache, and return the number removed
func (c *Cache[T]) freeOldestChunk() int {
    count := 0
    for i := 1; i <= c.chunkSize; i++ {
        key := c.shiftOrder()
        if key == "" {
            break
        }
        delete(c.data, key)
        count++
    }
    return count
}

func (c *Cache[T]) shiftOrder() string {
    if len(c.order) == 0 {
        return ""
    }
    key := c.order[0]
    c.order = c.order[1:]
    return key
}

func (c *Cache[T]) minSizeReached() bool {
    return ReadMemoryStats().MemFree <= c.MinMemFree
}

func ReadMemoryStats() Memory {
    file, err := os.Open("/proc/meminfo")
    if err != nil {
        panic(err)
    }
    defer file.Close()
    bufio.NewScanner(file)
    scanner := bufio.NewScanner(file)
    res := Memory{}
    for scanner.Scan() {
        key, value := parseLine(scanner.Text())
        switch key {
        case "MemTotal":
            res.MemTotal = value
        case "MemFree":
            res.MemFree = value
        case "MemAvailable":
            res.MemAvailable = value
        }
    }
    return res
}

func parseLine(raw string) (key string, value int) {
    text := strings.ReplaceAll(raw[:len(raw)-2], " ", "")
    keyValue := strings.Split(text, ":")
    return keyValue[0], toInt(keyValue[1])
}

func toInt(raw string) int {
    if raw == "" {
        return 0
    }
    res, err := strconv.Atoi(raw)
    if err != nil {
        panic(err)
    }
    return res
}

Одним из простых вариантов является использование группового кэша. Хотя его предполагаемая цель — предоставить кэш в памяти, который используется совместно кластером приложений, он может прекрасно работать и автономно.

Следующий код настраивает кэш группового кэша без каких-либо узлов (т.е. только ваш собственный экземпляр вашего приложения) с одной «группой» элементов, ограниченной 64 МБ памяти. Как только этот предел будет достигнут, внутренний кэш LRU удалит элемент.

func main() {
    maxCacheSize := int64(64 << 20)
    items := groupcache.NewGroup("your-items", maxCacheSize, groupcache.GetterFunc(func(ctx groupcache.Context, key string, dest groupcache.Sink) error {
        // Do something expensive
        result, err := doExpensiveThing(key)
        if err != nil {
            return err
        }
        return dest.SetBytes(result)
    }))

    ctx := context.Background()
    var data string
    err := items.Get(ctx, "your-item-key", groupcache.StringSink(&data))
    if err != nil {
        log.Fatal(err)
    }
}

Поскольку групповой кэш предназначен для кэширования «блобов» и распределения их по кластеру, его «приемники» (структура, в которую вы помещаете свои данные) могут работать только со строками, фрагментами байтов и сообщениями protobuf. Поэтому, если вы хотите кэшировать некоторые результаты базы данных, вам необходимо сериализовать их во что-то вроде JSON.

Если вы хотите кэшировать разные «типы вещей», каждый со своим объемом максимальной памяти, вы можете создать несколько групп.

Еще один компромисс заключается в том, что невозможно удалить элементы и установить срок их действия. Если вам требуется что-то из этого, groupcache, вероятно, не для вас.