PricingLoginStart free
Redis Caching & Messaging (Pub/Sub, Streams) · Lekcja

Strategie unieważniania cache

Dowiedz się, jak utrzymywać aktualność i spójność danych w cache za pomocą TTL, write-through, write-behind oraz unieważniania sterowanego zdarzeniami w Redis.

Lekcja 4 z 413 kroki

Strategie unieważniania cache to bezpłatna lekcja Redis Caching & Messaging (Pub/Sub, Streams) na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Redis Caching & Messaging (Pub/Sub, Streams), a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Redis Caching & Messaging (Pub/Sub, Streams) zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

Why Invalidation Matters

Caching speeds up reads, but a cache that serves stale data can be worse than no cache at all. Cache invalidation is the discipline of removing or refreshing entries when the underlying source of truth changes.

It is famously hard: there are only two hard things in computer science, and one of them is cache invalidation.

TTL-Based Expiry

The simplest strategy is time-to-live. You accept that data may be stale for at most N seconds.

  • SET key value EX 60 expires after 60 seconds
  • EXPIRE key 60 sets a TTL on an existing key
  • TTL key shows remaining seconds
SET user:42:profile "...json..." EX 60
TTL user:42:profile
EXPIRE user:42:profile 120

Write-Through Caching

In write-through caching, every write goes to both the database and the cache in the same operation. Reads are always fresh, at the cost of slower writes.

The application is responsible for keeping the two in lockstep.

def save_user(user):
    db.update(user)
    redis.set('user:' + user.id, serialize(user))
    return user

Write-Behind Caching

Write-behind (write-back) writes to the cache first and flushes to the database asynchronously. Writes are fast, but you risk data loss if Redis goes down before the flush.

Use a queue or stream to buffer pending writes.

redis.set('order:' + id, data)
redis.lpush('pending_writes', id)

Explicit Deletion on Update

The cache-aside + delete pattern: on every update to the database, delete the cached key. The next read repopulates it.

This avoids serving stale data and is simpler than keeping the cache value in sync.

def update_product(p):
    db.update(p)
    redis.delete('product:' + p.id)

Why Delete Beats Update

Deleting the key (instead of overwriting it) avoids a race condition: two concurrent updates could otherwise write values in the wrong order. With deletion, the next read always pulls the latest from the source of truth.

Versioned Keys

Instead of invalidating, bump a version number embedded in the key. Old keys expire naturally via TTL while new reads use the new key.

INCR config:version
GET config:version
SET config:v7:settings "..."

Event-Driven Invalidation

Publish an invalidation event whenever data changes. Other application nodes subscribe and clear their local caches. This pairs Redis Pub/Sub with caching.

redis.publish('invalidate', 'user:42')
# subscribers:
redis.subscribe('invalidate')

Tag-Based Invalidation

Group related keys under a tag set. When a tag becomes invalid, delete all member keys in one sweep.

  • SADD tag:user:42 product:1 product:2
  • On change: SMEMBERS tag:user:42 then DEL each
SADD tag:user:42 cart:42 wishlist:42
SMEMBERS tag:user:42

Avoiding Stampedes

When a hot key expires, many requests may hit the database at once (a cache stampede). Mitigate with a short lock, probabilistic early expiry, or serving slightly stale data while one worker refreshes.

SET lock:user:42 1 NX EX 5

Choosing a Strategy

There is no single best approach:

  • TTL for tolerable staleness
  • Delete-on-write for correctness
  • Event-driven for multi-node consistency
  • Versioning for bulk config changes

Quick Check

Test your understanding of invalidation strategies.

Odpowiedz w interaktywnej lekcji

Recap

You learned the major cache invalidation strategies: TTL expiry, write-through, write-behind, delete-on-write, versioned keys, event-driven, and tag-based invalidation, plus how to avoid cache stampedes. Pick the strategy that matches your tolerance for staleness and your consistency needs.

Bezpłatny start

Ucz się Redis Caching & Messaging (Pub/Sub, Streams) dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy
12
Lekcje
48
Zacznij naukę bezpłatnieWyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Strategie unieważniania cache” jest bezpłatna?

Tak — pełny tekst „Strategie unieważniania cache” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Redis Caching & Messaging (Pub/Sub, Streams), przejdź na CoddyKit PRO. Kurs Redis Caching & Messaging (Pub/Sub, Streams) zawiera 4 lekcji w sumie.

Co nauczysz się w „Strategie unieważniania cache”?

Dowiedz się, jak utrzymywać aktualność i spójność danych w cache za pomocą TTL, write-through, write-behind oraz unieważniania sterowanego zdarzeniami w Redis. Ćwiczysz Redis Caching & Messaging (Pub/Sub, Streams) z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Redis Caching & Messaging (Pub/Sub, Streams)?

Nie wymagamy żadnego doświadczenia. Redis Caching & Messaging (Pub/Sub, Streams) w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Strategie unieważniania cache”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Redis Caching & Messaging (Pub/Sub, Streams)?

Tak. Każda lekcja Redis Caching & Messaging (Pub/Sub, Streams) zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Zaawansowane wzorce buforowania
  2. Zarządzanie sesjami z Redis
  3. Ograniczanie częstotliwości i antywzorce
  4. Strategie unieważniania cache
← Powrót do Redis Caching & Messaging (Pub/Sub, Streams)