Concurrency-safe in-memory TTL cache for User

A concurrency-safe TTL cache

A single map holds both the value and the expiry in one entry (so two parallel maps cannot drift out of sync). A sync.RWMutex admits many concurrent Get calls under RLock and serializes writes under 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) // sweep at the TTL cadence
	return c
}

// Set writes the value and resets its time-to-live.
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 returns (User, true) only for a fresh entry.
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 // missing key or expired
	}
	return e.user, true
}

// Close stops the background janitor so its goroutine does not leak.
func (c *Cache) Close() {
	close(c.stop)
}

// janitor periodically removes expired entries until the cache is closed.
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 removes every expired entry in one pass under 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)
		}
	}
}

Three correctness invariants:

• Expiry is checked on read. Get compares time.Now() against expiresAt and returns a miss when expired — even if the background cleaner has not deleted the key yet.
• Every access is locked. Writes (Set, cleanup) take Lock; reads (Get) take RLock. Unsynchronized concurrent access to a Go map is a data race and triggers fatal error: concurrent map ....
• Eviction is mandatory and the goroutine must not leak. A lazy miss on Get is not enough: a key that is never requested again would linger in the map forever. So janitor calls cleanup under Lock on a time.Ticker, and Close closes the stop channel — the select observes it and returns, so the goroutine does not leak once the cache is gone.