Как управлять количеством кэша?

Управление количеством кэша в Go

Управление размером кэша — критически важная задача для контроля использования памяти и предотвращения утечек. В Go подход зависит от типа используемого кэша. Рассмотрим основные стратегии и подводные камни.

Типовые подходы к ограничению кэша

1. LRU-кэш с фиксированной ёмкостью

Наиболее распространённый подход — использование реализации Least Recently Used с ограничением по количеству элементов или объёму памяти.

import (
    "container/list"
    "sync"
)

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

type cacheEntry struct {
    key   string
    value interface{}
    size  int64 // Размер элемента в байтах
}

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

func (c *LRUCache) Set(key string, value interface{}, size int64) {
    c.mu.Lock()
    defer c.mu.Unlock()
    
    if elem, exists := c.cache[key]; exists {
        // Обновление существующего значения
        c.lruList.MoveToFront(elem)
        entry := elem.Value.(*cacheEntry)
        entry.value = value
        entry.size = size
        return
    }
    
    // Удаляем старые элементы при переполнении
    for c.currentSize() + size > int64(c.capacity) {
        c.evictOldest()
    }
    
    entry := &cacheEntry{key: key, value: value, size: size}
    elem := c.lruList.PushFront(entry)
    c.cache[key] = elem
}

2. Кэш с TTL (Time-to-Live)

Автоматическое удаление устаревших записей помогает контролировать размер.

import (
    "sync"
    "time"
)

type TTLCache struct {
    items    map[string]cacheItem
    mu       sync.RWMutex
    ttl      time.Duration
    maxItems int
}

type cacheItem struct {
    value    interface{}
    expiry   time.Time
    size     int64
}

func NewTTLCache(ttl time.Duration, maxItems int) *TTLCache {
    c := &TTLCache{
        items:    make(map[string]cacheItem),
        ttl:      ttl,
        maxItems: maxItems,
    }
    
    go c.cleanupWorker() // Фоновая очистка
    return c
}

func (c *TTLCache) cleanupWorker() {
    ticker := time.NewTicker(c.ttl / 2)
    for range ticker.C {
        c.clearExpired()
    }
}

func (c *TTLCache) clearExpired() {
    c.mu.Lock()
    defer c.mu.Unlock()
    
    now := time.Now()
    for key, item := range c.items {
        if now.After(item.expiry) || len(c.items) > c.maxItems {
            delete(c.items, key)
        }
    }
}

Ключевые аспекты управления

Мониторинг использования памяти

Регулярный контроль размера кэша с встроенными метриками:

type MonitoredCache struct {
    cache      *LRUCache
    maxMemory  int64
    currentMem int64
    stats      CacheStats
    mu         sync.RWMutex
}

func (mc *MonitoredCache) GetMemoryUsage() float64 {
    mc.mu.RLock()
    defer mc.mu.RUnlock()
    return float64(mc.currentMem) / float64(mc.maxMemory) * 100
}

func (mc *MonitoredCache) ShouldEvict() bool {
    return mc.GetMemoryUsage() > 80.0 // Начинаем очистку при 80% заполнении
}

Адаптивные стратегии

• Динамическое изменение ёмкости в зависимости от свободной памяти системы
• Приоритетное кэширование часто используемых элементов
• Прогрессивное вытеснение при приближении к лимитам

Практические рекомендации

1. Всегда устанавливайте жёсткие лимиты — даже при использовании слабых ссылок (sync.Map или weakref)
2. Инструментируйте кэш — добавьте метрики попаданий (hit/miss ratio), чтобы оценивать эффективность
3. Реализуйте механизмы сброса — возможность очистки кэша по требованию или по таймеру
4. Учитывайте стоимость вычисления — дорогие в вычислении данные стоит кэшировать дольше
5. Используйте готовые решения — github.com/hashicorp/golang-lru, github.com/patrickmn/go-cache

Распространённые ошибки и их решения

• Утечка памяти из-за глобального кэша → Используйте dependency injection и возможность замены реализации
• Блокировки при конкурентном доступе → Применяйте sync.RWMutex или шардирование кэша
• Неконтролируемый рост при ошибках → Добавьте circuit breaker на запись в кэш
• Кэширование больших объектов → Сжимайте данные или храните ссылки на дисковый кэш

Заключение

Управление размером кэша требует баланса между производительностью и потреблением памяти. В Go необходимо явно контролировать лимиты через capacity-ограничения, TTL-механизмы и регулярную очистку устаревших данных. Мониторинг реального использования через pprof и метрики позволяет настраивать параметры оптимальным образом для конкретного приложения. Использование проверенных библиотек сокращает количество ошибок, но понимание внутренних механизмов остаётся обязательным для сложных сценариев.