Richtlinien zur Cache-Eviction
Erkunden Sie, wie Caches bei vollem Speicher entscheiden, welche Daten sie behalten und verwerfen. Behandelt werden LRU, LFU, FIFO, TTL und ihre jeweiligen Abwägungen.
Richtlinien zur Cache-Eviction ist eine kostenlose System Design Basics for Backend Developers-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des System Design Basics for Backend Developers-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der System Design Basics for Backend Developers-Kurs umfasst insgesamt 4 Lektionen.
Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.
Why Eviction Is Necessary
A cache is fast because it lives in limited memory. When it fills up, it must evict something to make room for new data. The eviction policy decides what to drop.
A good policy keeps the data most likely to be reused.
Hit Rate Is the Goal
The metric that matters is the hit rate: the fraction of requests served from cache. A better eviction policy raises the hit rate, which means fewer slow trips to the database or origin.
hits = 850
misses = 150
hit_rate = hits / (hits + misses)
print('hit rate:', hit_rate)FIFO
FIFO (First In, First Out) evicts the oldest inserted item regardless of usage. It is simple but ignores access patterns, so a frequently used old item can be wrongly evicted.
LRU: Least Recently Used
LRU evicts the item that has not been accessed for the longest time. It assumes recently used data will be used again soon — true for most workloads, which is why LRU is the default in many caches.
Implementing LRU
A classic LRU uses an ordered map. On access, move the key to the most-recent end; when full, evict from the least-recent end.
from collections import OrderedDict
class LRU:
def __init__(self, cap):
self.cap = cap
self.d = OrderedDict()
def get(self, k):
if k in self.d:
self.d.move_to_end(k)
return self.d[k]
def put(self, k, v):
self.d[k] = v
self.d.move_to_end(k)
if len(self.d) > self.cap:
self.d.popitem(last=False)
c = LRU(2)
c.put('a', 1); c.put('b', 2); c.get('a'); c.put('c', 3)
print(list(c.d.keys()))LFU: Least Frequently Used
LFU evicts the item accessed the fewest times. It favors long-term popular items over recent bursts. The downside: a once-popular item can linger long after it stops being useful.
TTL-Based Expiration
A TTL (time to live) expires items after a fixed duration regardless of memory pressure. It bounds staleness and is often combined with LRU: TTL controls freshness, LRU controls memory.
SET session:42 "..." EX 3600
# expires in 3600 secondsRandom and Allkeys Variants
Some caches offer random eviction (cheap, surprisingly decent) and scope variants: evict only keys with a TTL set, or evict from all keys. Redis exposes policies like allkeys-lru and volatile-ttl.
Thundering Herd on Eviction
When a hot key is evicted or expires, many clients may simultaneously rebuild it — a thundering herd that hammers the origin. Mitigate with request coalescing (single-flight) or slightly randomized TTLs to spread out expirations.
Choosing a Policy
Match the policy to the workload:
- Recency-driven traffic: LRU
- Stable popularity: LFU
- Freshness-critical data: TTL
- Uniform access: random is fine and cheap
Eviction in a CDN
CDNs apply the same ideas at the edge. Each edge node has finite storage and evicts (often LRU) plus honors Cache-Control: max-age as a TTL. Understanding eviction explains why a cold edge node has a low initial hit rate.
Quick Check
Test your understanding of eviction policies.
Recap
You learned how caches manage limited memory:
- Eviction policies aim to maximize hit rate
- FIFO, LRU, LFU, TTL, and random each suit different patterns
- Thundering herds need coalescing or jittered TTLs
- CDNs apply the same eviction logic at the edge
Häufig gestellte Fragen
Ist die Lektion „Richtlinien zur Cache-Eviction“ kostenlos?
Ja — der vollständige Text von „Richtlinien zur Cache-Eviction“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des System Design Basics for Backend Developers-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der System Design Basics for Backend Developers-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Richtlinien zur Cache-Eviction“?
Erkunden Sie, wie Caches bei vollem Speicher entscheiden, welche Daten sie behalten und verwerfen. Behandelt werden LRU, LFU, FIFO, TTL und ihre jeweiligen Abwägungen. Du übst System Design Basics for Backend Developers mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um System Design Basics for Backend Developers zu starten?
Keine Vorkenntnisse erforderlich. System Design Basics for Backend Developers auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.
Wie lange dauert die Lektion „Richtlinien zur Cache-Eviction“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser System Design Basics for Backend Developers-Lektion Code schreiben und ausführen?
Ja. Jede System Design Basics for Backend Developers-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Muster zur Cache-Invalidierung
- CDN-Integration und Edge-Caching
- Verteiltes Caching mit Redis
- Richtlinien zur Cache-Eviction