แคชถล่ม การทำให้ใช้ไม่ได้ และความสอดคล้อง

A cache stampede (a.k.a. thundering herd or dog-piling) happens when a hot cache entry expires and many concurrent requests all miss at once. Each request then hits the slow backing store (database, remote API) to recompute the same value.

• One popular key expires
• 1,000 requests arrive in the same instant
• All 1,000 see a miss and stampede the database
• The DB spikes, latency explodes, sometimes it falls over

In this lesson you'll learn to prevent thundering herds and stale reads using key design, conditional caching, and synchronized loads in Spring Boot 4.

Spring's @Cacheable supports sync = true. When several threads miss the same key at the same time, only one thread computes the value while the others block and wait for the result. This collapses the herd to a single load per key.

• Requires a cache manager that supports synchronized loading (Caffeine does)
• You cannot combine sync = true with multiple cache names, unless, or a custom condition that depends on the return value

With Caffeine, sync = true maps to Cache.get(key, mappingFunction), which guarantees the mapping function runs at most once per key for concurrent callers. Here is the core idea in plain Java that an online judge can run.

Notice how many threads request the same key, yet the expensive load happens only once.

Caching the wrong values causes stale or useless entries. Use condition and unless to be precise:

• condition is evaluated before the method runs (on the arguments)
• unless is evaluated after the method runs (on the return value), so it can inspect the result

A classic rule: never cache null or empty results, so a transient miss doesn't get pinned in the cache.

Bad keys cause both stampedes and wrong reads. Good cache keys are:

• Stable: the same logical input always maps to the same key
• Specific: include every input that changes the result (tenant, locale, filters)
• Collision-free: two different inputs never produce the same key

Avoid relying on default key generation when a method has multiple parameters; build an explicit composite key with SpEL so you control exactly what varies.

When many methods share a key shape, a custom KeyGenerator keeps keys consistent and avoids copy-paste SpEL. Register it as a bean and reference it by name with keyGenerator.

This composes the class name, method name, and arguments into a single stable string, eliminating accidental collisions between methods that share argument types.

Stale reads happen when data changes but the cache still holds the old value. Evict on every write path so the next read reloads fresh data.

• @CacheEvict(key = ...) removes a single entry
• @CacheEvict(allEntries = true) clears the whole cache region
• beforeInvocation = true evicts even if the method throws, useful for deletes

@CachePut always runs the method and then stores the result, refreshing the entry instead of evicting it. This avoids a brief empty window between evict and the next read, which under load could itself trigger a mini-stampede.

Use @CachePut when the write method returns the new authoritative value and the key matches the read key exactly.

Caffeine is a per-instance, in-process cache. With multiple app nodes, an evict on node A does not clear Caffeine on node B, causing stale reads. Solutions:

• Use a shared distributed cache (Redis) so eviction is visible to all nodes
• Or run a two-tier (near-cache) setup: Caffeine in front of Redis, with a pub/sub invalidation message to flush local copies

Configure a Redis cache manager with per-cache TTLs to bound staleness even if an eviction message is missed.

If many keys are created together (for example after a deploy or a bulk import), they can also expire together, recreating a synchronized stampede at TTL boundaries. Add a small random jitter to spread expirations out.

The judge-runnable snippet below shows how jitter turns a single sharp expiry spike into a smooth band of expiry times.

A robust caching method combines several of these techniques:

• sync = true to collapse concurrent misses into one load
• unless to skip caching empty results that should not be pinned
• explicit key that includes every input affecting the result
• jittered TTL on the cache config to avoid synchronized expiry

Pair the read method with @CacheEvict or @CachePut on every write so reads never go stale.

You learned how to prevent thundering herds and stale reads:

• Stampede: a hot key expires and many requests recompute the same value at once
• sync = true: collapses concurrent misses into a single synchronized load per key
• condition / unless: cache precisely; never pin null or empty results
• Key design: stable, specific, collision-free keys including every input that changes the result
• @CacheEvict / @CachePut: invalidate or refresh on every write to avoid stale reads
• Distributed consistency: Redis or pub/sub invalidation keeps multiple nodes coherent; per-cache TTLs bound staleness
• Jittered TTL: de-synchronizes expirations so keys don't all expire together