Redis: cachelagring och meddelanden (Pub/Sub, Streams) · Lektion

Strategier för cache-invalidering

Lär Er att hålla cachad data aktuell och konsekvent med TTL:er, write-through, write-behind och händelsestyrd invalidering i Redis.

Lektion 4 av 413 steg

Strategier för cache-invalidering är en gratis lektion i Redis: cachelagring och meddelanden (Pub/Sub, Streams) på CoddyKit. Detta är lektion 4 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Redis: cachelagring och meddelanden (Pub/Sub, Streams), och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Redis: cachelagring och meddelanden (Pub/Sub, Streams) innehåller totalt 4 lektioner.

Varför invalidering är viktigt

Cachning snabbar upp läsningar, men en cache som levererar föråldrade data kan vara sämre än ingen cache alls. Cache-invalidering är metoden att ta bort eller uppdatera poster när den underliggande källan ändras.

Det är berömt svårt: det finns bara två riktigt svåra saker inom datavetenskap, och en av dem är cache-invalidering.

Utgång baserad på TTL

Den enklaste strategin är time-to-live. Ni accepterar att data kan vara föråldrade i högst N sekunder.

SET key value EX 60 löper ut efter 60 sekunder
EXPIRE key 60 anger en TTL för en befintlig nyckel
TTL key visar återstående sekunder

SET user:42:profile "...json..." EX 60
TTL user:42:profile
EXPIRE user:42:profile 120

Write-through-cachning

Vid write-through-cachning går varje skrivning till både databasen och cachen i samma operation. Läsningar är alltid aktuella, men skrivningarna blir långsammare.

Applikationen ansvarar för att hålla de två synkroniserade.

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

Write-behind-cachning

Write-behind (write-back) skriver först till cachen och tömmer den asynkront till databasen. Skrivningar går snabbt, men Ni riskerar dataförlust om Redis går ner innan tömningen.

Använd en kö eller stream för att buffra väntande skrivningar.

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

Explicit borttagning vid uppdatering

Mönstret cache-aside + delete innebär att den cachade nyckeln tas bort vid varje uppdatering av databasen. Nästa läsning fyller på den igen.

Detta förhindrar att föråldrade data levereras och är enklare än att hålla cachevärdet synkroniserat.

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

Varför borttagning är bättre än uppdatering

Genom att ta bort nyckeln i stället för att skriva över den undviker Ni ett kapplöpningstillstånd: två samtidiga uppdateringar skulle annars kunna skriva värden i fel ordning. Vid borttagning hämtar nästa läsning alltid det senaste värdet från källan.

Versionshanterade nycklar

I stället för att invalidera nyckeln ökar Ni ett versionsnummer som ingår i nyckeln. Gamla nycklar löper ut naturligt via TTL, medan nya läsningar använder den nya nyckeln.

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

Händelsestyrd invalidering

Publicera en invalideringshändelse varje gång data ändras. Andra applikationsnoder prenumererar och tömmer sina lokala cacheminnen. Detta kombinerar Redis Pub/Sub med cachning.

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

Invalidering baserad på taggar

Gruppera relaterade nycklar i en taggmängd. När en tagg blir ogiltig tar Ni bort alla medlemsnycklar i ett svep.

SADD tag:user:42 product:1 product:2
Vid ändring: SMEMBERS tag:user:42 och sedan DEL för varje nyckel

SADD tag:user:42 cart:42 wishlist:42
SMEMBERS tag:user:42

Undvik cache-stampedes

När en het nyckel löper ut kan många begäranden nå databasen samtidigt, vilket orsakar en cache-stampede. Begränsa detta med ett kortvarigt lås, tidig probabilistisk utgång eller genom att leverera något föråldrade data medan en arbetsprocess uppdaterar värdet.

SET lock:user:42 1 NX EX 5

Välj en strategi

Det finns ingen enskild bästa metod:

TTL när en viss föråldring kan tolereras
Delete-on-write för korrekthet
Händelsestyrning för konsekvens mellan flera noder
Versionshantering för större konfigurationsändringar

Snabbtest

Testa Er förståelse av invalideringsstrategier.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt Er de viktigaste strategierna för cache-invalidering: TTL-utgång, write-through, write-behind, delete-on-write, versionshanterade nycklar, händelsestyrd invalidering och taggbaserad invalidering, samt hur cache-stampedes undviks. Välj den strategi som passar Er tolerans för föråldrade data och Era krav på konsekvens.

Gratis att börja

Lär dig Redis: cachelagring och meddelanden (Pub/Sub, Streams) med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Strategier för cache-invalidering” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Redis: cachelagring och meddelanden (Pub/Sub, Streams), inklusive ”Strategier för cache-invalidering”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Redis: cachelagring och meddelanden (Pub/Sub, Streams) innehåller totalt 4 lektioner.

Vad lär jag mig i ”Strategier för cache-invalidering”?

Lär Er att hålla cachad data aktuell och konsekvent med TTL:er, write-through, write-behind och händelsestyrd invalidering i Redis. Ni övar på Redis: cachelagring och meddelanden (Pub/Sub, Streams) med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Redis: cachelagring och meddelanden (Pub/Sub, Streams)?

Du behöver inga förkunskaper. Utbildningen i Redis: cachelagring och meddelanden (Pub/Sub, Streams) på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Strategier för cache-invalidering”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Redis: cachelagring och meddelanden (Pub/Sub, Streams)-lektionen?

Ja. Varje Redis: cachelagring och meddelanden (Pub/Sub, Streams)-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Redis: cachelagring och meddelanden (Pub/Sub, Streams)