Spring Boot 4 Complete Guide · レッスン

キャッシュスタンピード、無効化、整合性

キー設計、条件付きキャッシュ、同期ロードで、Thundering Herdと古い読み取りを防ぎます。

レッスン 4/413 ステップ

「キャッシュスタンピード、無効化、整合性」はCoddyKit上の無料Spring Boot 4 Complete Guideレッスンです。これはレッスン4/4です。下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応の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 チューターと学ぶ Java — 無料

ブラウザでリアルコードを書いて実行し、24/7 の AI チューターから瞬時にサポートを受け、ウェブまたはアプリで続きから学習できます。

コース: 21
レッスン: 84

無料で学習を始めるコース全体を表示

よくある質問

「キャッシュスタンピード、無効化、整合性」レッスンは無料ですか？

はい。「キャッシュスタンピード、無効化、整合性」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、Spring Boot 4 Complete Guideコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 Spring Boot 4 Complete Guideコースには全4レッスンが含まれています。

「キャッシュスタンピード、無効化、整合性」で何を学びますか？

キー設計、条件付きキャッシュ、同期ロードで、Thundering Herdと古い読み取りを防ぎます。ブラウザで直接実行するハンズオンコードでSpring Boot 4 Complete Guideを演習し、24時間対応の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フィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

← Spring Boot 4 Complete Guideに戻る