0Pricing
Spring Boot 4 Complete Guide · 课时

缓存击穿、失效与一致性

通过键设计、条件缓存和同步加载，防止惊群效应与读取过期数据。

缓存击穿、失效与一致性 是 CoddyKit 上的免费 Spring Boot 4 Complete Guide 课时。 这是第 4 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Spring Boot 4 Complete Guide 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Spring Boot 4 Complete Guide 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

The Problem: Cache Stampede

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.

Synchronized Loading with sync = true

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
@Service
public class ProductService {

    @Cacheable(cacheNames = "products", key = "#id", sync = true)
    public Product findById(Long id) {
        // Only ONE thread runs this per key, even under a stampede
        return loadFromDatabase(id);
    }
}

How sync Collapses the Herd

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.

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    static AtomicInteger dbLoads = new AtomicInteger();
    static ConcurrentHashMap<Long, Object> cache = new ConcurrentHashMap<>();

    static String load(Long id) {
        // computeIfAbsent runs the mapping function at most once per key
        return (String) cache.computeIfAbsent(id, k -> {
            dbLoads.incrementAndGet();
            try { Thread.sleep(50); } catch (InterruptedException e) {}
            return "product-" + k;
        });
    }

    public static void main(String[] args) throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(20);
        CountDownLatch done = new CountDownLatch(1000);
        for (int i = 0; i < 1000; i++) {
            pool.submit(() -> { load(42L); done.countDown(); });
        }
        done.await();
        pool.shutdown();
        System.out.println("DB loads for hot key: " + dbLoads.get());
    }
}

Conditional Caching with unless

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.

@Cacheable(
    cacheNames = "products",
    key = "#id",
    unless = "#result == null")
public Product findById(Long id) {
    return repository.findById(id).orElse(null);
}

Key Design: Stable, Specific, Collision-Free

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.

@Cacheable(
    cacheNames = "catalog",
    key = "'cat:' + #tenantId + ':' + #locale + ':' + #category",
    sync = true)
public List<Product> listCatalog(String tenantId, String locale, String category) {
    return repository.findByTenantAndCategory(tenantId, category, locale);
}

A Reusable KeyGenerator

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.

@Component("scopedKeyGen")
public class ScopedKeyGenerator implements KeyGenerator {

    @Override
    public Object generate(Object target, Method method, Object... params) {
        StringBuilder sb = new StringBuilder(target.getClass().getSimpleName())
            .append(':').append(method.getName());
        for (Object p : params) {
            sb.append(':').append(p);
        }
        return sb.toString();
    }
}

Invalidation on Writes with @CacheEvict

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
@CacheEvict(cacheNames = "products", key = "#product.id")
public Product update(Product product) {
    return repository.save(product);
}

@CacheEvict(cacheNames = "products", key = "#id", beforeInvocation = true)
public void delete(Long id) {
    repository.deleteById(id);
}

Atomic Update with @CachePut

@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.

@CachePut(cacheNames = "products", key = "#result.id")
public Product create(ProductForm form) {
    Product saved = repository.save(form.toEntity());
    return saved; // freshly written value is placed into the cache
}

Consistency Across Nodes with Redis

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.

@Bean
public RedisCacheManager cacheManager(RedisConnectionFactory cf) {
    RedisCacheConfiguration base = RedisCacheConfiguration.defaultCacheConfig()
        .entryTtl(Duration.ofMinutes(10))
        .disableCachingNullValues();

    Map<String, RedisCacheConfiguration> perCache = Map.of(
        "products", base.entryTtl(Duration.ofMinutes(5)),
        "catalog",  base.entryTtl(Duration.ofMinutes(1)));

    return RedisCacheManager.builder(cf)
        .cacheDefaults(base)
        .withInitialCacheConfigurations(perCache)
        .build();
}

Bounding Staleness with Jittered TTL

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.

import java.util.concurrent.ThreadLocalRandom;

public class Main {
    static long baseTtlMs = 300_000; // 5 minutes

    static long ttlWithJitter() {
        // +/- 10% jitter to de-synchronize expirations
        long jitter = (long) (baseTtlMs * 0.10);
        return baseTtlMs + ThreadLocalRandom.current().nextLong(-jitter, jitter);
    }

    public static void main(String[] args) {
        long min = Long.MAX_VALUE, max = Long.MIN_VALUE;
        for (int i = 0; i < 5; i++) {
            long ttl = ttlWithJitter();
            System.out.println("key " + i + " ttl(ms)=" + ttl);
            min = Math.min(min, ttl);
            max = Math.max(max, ttl);
        }
        System.out.println("spread(ms)=" + (max - min));
    }
}

Putting It Together

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.

@Service
public class CatalogService {

    @Cacheable(
        cacheNames = "catalog",
        key = "#tenantId + ':' + #category",
        sync = true,
        unless = "#result == null || #result.isEmpty()")
    public List<Product> list(String tenantId, String category) {
        return repository.find(tenantId, category);
    }

    @CacheEvict(cacheNames = "catalog", key = "#tenantId + ':' + #category")
    public void invalidate(String tenantId, String category) {
        // called after any write that changes this slice
    }
}

Quick Check

Test your understanding of stampede prevention in Spring Boot 4.

Recap

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

常见问题解答

「缓存击穿、失效与一致性」课时是免费的吗？

是的 — 「缓存击穿、失效与一致性」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Spring Boot 4 Complete Guide 课程的其余内容，请升级到 CoddyKit PRO。 Spring Boot 4 Complete Guide 课程共包含 4 节课。

「缓存击穿、失效与一致性」这节课中我会学到什么？

通过键设计、条件缓存和同步加载，防止惊群效应与读取过期数据。 你通过在浏览器中直接运行的动手代码来练习 Spring Boot 4 Complete Guide，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Spring Boot 4 Complete Guide 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Spring Boot 4 Complete Guide 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 4 节课，共 4 节。

「缓存击穿、失效与一致性」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Spring Boot 4 Complete Guide 课中编写并运行代码吗？

能。每节 Spring Boot 4 Complete Guide 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. Spring 缓存抽象基础
  2. 使用 Caffeine 调优内存缓存
  3. 使用 Redis 与 TTL 实现分布式缓存
  4. 缓存击穿、失效与一致性
← 返回 Spring Boot 4 Complete Guide