Cache Stratejileri — Defter Ne Zaman Yalan Söyler?

Mahalle bakkalı her fiyat sorusunda arkadaki depoya yürümez. Tezgâhta bir defter tutar: bir kez baktığı fiyatı oraya yazar, sonra defterden söyler.

Cache-aside: önce deftere bak

Cache-aside?Terimin tanımını açcache-asideUygulamanın önce cache'e baktığı, bulamazsa veritabanından okuyup cache'e koyduğu düzen. Cache veritabanının yanında durur; düşerse uygulama veritabanından devam eder.Sözlükte gör → düzeninde uygulama önce cache’e bakar. Bulursa (hit) hemen döner; bulamazsa (miss) veritabanından okur, cache’e koyar ve döner.

oku:   cache.get(key) ──bulundu──→ döndür
                     └─yok──→ db.read(key) → cache.set(key, değer, TTL) → döndür

Cache her şeye değmez. Çok okunan, az değişen ve biraz eski görünmesi dert olmayan veri iyi adaydır: ürün sayfası, kategori listesi, döviz kuru ekranı. Ödemede kullanılacak fiyat ise veritabanından okunur.

Yazınca defter ne olacak?

Veri değişince cache’e ne olacağına dair birkaç düzen var. Write-through: her yazma hem veritabanına hem cache’e aynı anda gider. Write-behind?Terimin tanımını açwrite-behindYazmanın önce cache'e yapılıp veritabanına sonradan toplu aktarıldığı düzen. Yazma hızlanır; cache düşerse henüz aktarılmamış değişiklikler kaybolabilir.Sözlükte gör →: yazma önce cache’e gider, veritabanına sonra toplu yazılır; hızlıdır ama cache düşerse yazma kaybolabilir.

Cache-aside kullanan çoğu sistem ise yazarken ya cache’teki değeri günceller ya da girdiyi siler. İkisi aynı görünür.

Girdiyi silmek bu yarışı kapatır. İki silme hangi sırayla gelirse gelsin sonuç aynıdır: girdi yoktur ve sonraki okuma veritabanından taze değeri getirir.

Satır satır: yavaş okuyan

Bu yarış nadirdir: okuyanın veritabanı okuması ile cache’e yazması arasındaki boşluk, yazanın bütün işinden uzun sürmelidir. Nadir ama imkânsız değil.

Bu yüzden her girdiye bir TTL?Terimin tanımını açTTLTime to live: bir cache girdisinin ne kadar süre geçerli sayılacağı. Süre dolunca girdi silinir ve sonraki okuma kaynağa gider; o süre boyunca eski veri görülebilir.Sözlükte gör → verilir. TTL yarışı önlemez; eski değerin en fazla ne kadar yaşayacağını söyler.

Kendin gör

Başlangıçta fiyat hem veritabanında hem cache’te 100. Yazan fiyatı değiştirirken aynı anda başka bir şey oluyor.

1. Varsayılanı oynat. İki yazan, ikisi de cache’e değer koyuyor: cache 120, veritabanı 130. TTL yok, yanlışlık süresiz.
2. Yazarken “DB’ye yaz, sonra cache’ten sil” seç. Aynı yarış, ama sonraki okuma 130’u getiriyor.
3. “Yavaş bir okuyan araya giriyor” seç. Üç stratejinin üçünde de eski fiyat geri giriyor. TTL’i aç ve farkı gör.

Tuzaklar

Hepsi aynı anda bitiyor. Deploy sonrası ısıtılan binlerce girdi aynı TTL’le yazılırsa aynı saniyede biter ve hepsi birden veritabanına gider. Süreye rastgele küçük bir pay eklemek bitişleri zamana yayar.

Çok okunan tek girdi bitiyor. O anda yüzlerce istek aynı sorguyu çalıştırır: cache stampede?Terimin tanımını açcache stampedeSık okunan bir cache girdisi silindiği anda çok sayıda isteğin aynı değeri aynı anda kaynaktan hesaplamaya çalışması. Veritabanına ani bir yük bindirir.Sözlükte gör →. Çözüm, girdiyi tek bir isteğin yüklemesi ve diğerlerinin onu beklemesidir; Spring Cache dersindeki sync = true bunun bir örneği.

Olmayan anahtarlar. Var olmayan bir ürün hiç cache’e girmez ve her soru veritabanına gider. “Yok” cevabı da kısa bir süreyle saklanır.

1
@Component
2
class PriceCache {
3

4
    private static final Duration BASE_TTL = Duration.ofMinutes(10);
5
    private static final Duration MISSING_TTL = Duration.ofSeconds(30);
6
    private static final String MISSING = "-";
7

8
    private final StringRedisTemplate redis;
9
    private final PriceRepository prices;
10

11
    PriceCache(StringRedisTemplate redis, PriceRepository prices) {
12
        this.redis = redis;
13
        this.prices = prices;
14
    }
15

16
    Optional<BigDecimal> find(String sku) {
17
        String key = key(sku);
18
        String cached = redis.opsForValue().get(key);
19
        if (cached != null) {
20
            return MISSING.equals(cached) ? Optional.empty() : Optional.of(new BigDecimal(cached));
21
        }
22

23
        Optional<BigDecimal> fresh = prices.findPriceBySku(sku);
24
        // "No such product" is remembered briefly too, so unknown SKUs do not all reach the database.
25
        redis.opsForValue().set(key,
26
                fresh.map(BigDecimal::toPlainString).orElse(MISSING),
27
                fresh.isPresent() ? withJitter(BASE_TTL) : MISSING_TTL);
28
        return fresh;
29
    }
30

31
    void evict(String sku) {
32
        redis.delete(key(sku));
33
    }
34

35
    private static String key(String sku) {
36
        return "price:" + sku;
37
    }
38

39
    // Up to 10% extra, so entries written together do not all expire together.
40
    private static Duration withJitter(Duration base) {
41
        return base.plusMillis(ThreadLocalRandom.current().nextLong(base.toMillis() / 10 + 1));
42
    }
43
}

1
@Service
2
class PriceService {
3

4
    private final PriceRepository prices;
5
    private final ApplicationEventPublisher events;
6

7
    PriceService(PriceRepository prices, ApplicationEventPublisher events) {
8
        this.prices = prices;
9
        this.events = events;
10
    }
11

12
    @Transactional
13
    public void change(String sku, BigDecimal price) {
14
        prices.updatePrice(sku, price);
15
        events.publishEvent(new PriceChanged(sku));
16
    }
17
}
18

19
record PriceChanged(String sku) {
20
}

1
@Component
2
class PriceChangedListener {
3

4
    private final PriceCache cache;
5

6
    PriceChangedListener(PriceCache cache) {
7
        this.cache = cache;
8
    }
9

10
    // Runs only after the commit: from here on the database can no longer hand out the old price.
11
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
12
    void on(PriceChanged event) {
13
        cache.evict(event.sku());
14
    }
15
}

Kendini sına

Önce hızlı bir ısınma: puan yok, kayıt yok. Sonra asıl sorular.