Потокобезопасный in-memory TTL-кэш для User

Потокобезопасный TTL-кэш

Одна map хранит и значение, и момент истечения в одной записи (так не рассинхронизируются два словаря). sync.RWMutex пропускает много одновременных Get под RLock и сериализует записи под Lock.

package main

import (
	"sync"
	"time"
)

type User struct {
	ID   string
	Name string
}

type entry struct {
	user      User
	expiresAt time.Time
}

type Cache struct {
	mu   sync.RWMutex
	data map[string]entry
	ttl  time.Duration
	stop chan struct{}
}

func NewCache(ttl time.Duration) *Cache {
	c := &Cache{
		data: make(map[string]entry),
		ttl:  ttl,
		stop: make(chan struct{}),
	}
	go c.janitor(ttl) // чистка с периодом TTL
	return c
}

// Set записывает значение и заново выставляет срок жизни.
func (c *Cache) Set(u User) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.data[u.ID] = entry{user: u, expiresAt: time.Now().Add(c.ttl)}
}

// Get возвращает (User, true) только для свежей записи.
func (c *Cache) Get(id string) (User, bool) {
	c.mu.RLock()
	e, ok := c.data[id]
	c.mu.RUnlock()
	if !ok || time.Now().After(e.expiresAt) {
		return User{}, false // нет ключа или срок истёк
	}
	return e.user, true
}

// Close останавливает фонового чистильщика, чтобы его goroutine не утекала.
func (c *Cache) Close() {
	close(c.stop)
}

// janitor периодически чистит истёкшие записи, пока кэш не закрыт.
func (c *Cache) janitor(interval time.Duration) {
	t := time.NewTicker(interval)
	defer t.Stop()
	for {
		select {
		case <-t.C:
			c.cleanup()
		case <-c.stop:
			return
		}
	}
}

// cleanup удаляет все истёкшие записи за один проход под Lock.
func (c *Cache) cleanup() {
	now := time.Now()
	c.mu.Lock()
	defer c.mu.Unlock()
	for id, e := range c.data {
		if now.After(e.expiresAt) {
			delete(c.data, id)
		}
	}
}

Три инварианта корректности:

• Срок проверяется на чтении. Get сравнивает time.Now() с expiresAt и при истечении возвращает промах — даже если фоновый чистильщик ещё не удалил ключ.
• Каждый доступ под блокировкой. Запись (Set, cleanup) — под Lock, чтение (Get) — под RLock. Конкурентный доступ к map в Go без синхронизации — гонка данных и fatal error: concurrent map ....
• Удаление обязательно и без утечки goroutine. Ленивого промаха на Get мало: ключ, который больше не запрашивают, остался бы в map навсегда. Поэтому janitor периодически (по time.Ticker) вызывает cleanup под Lock, а Close закрывает канал stop — select ловит это и завершает goroutine, чтобы она не утекала после удаления кэша.