Politiche di espulsione della cache
Esplori come le cache decidono cosa conservare e cosa eliminare quando la memoria è piena, analizzando LRU, LFU, FIFO, TTL e i relativi compromessi.
Politiche di espulsione della cache è una lezione System Design Basics for Backend Developers gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento System Design Basics for Backend Developers, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso System Design Basics for Backend Developers include 4 lezioni in totale.
Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.
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
Impara System Design Basics for Backend Developers con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 12
- Lezioni
- 48
Domande Frequenti
La lezione «Politiche di espulsione della cache» è gratuita?
Sì — il testo completo di «Politiche di espulsione della cache» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso System Design Basics for Backend Developers, passa a CoddyKit PRO. Il corso System Design Basics for Backend Developers include 4 lezioni in totale.
Cosa imparerò in «Politiche di espulsione della cache»?
Esplori come le cache decidono cosa conservare e cosa eliminare quando la memoria è piena, analizzando LRU, LFU, FIFO, TTL e i relativi compromessi. Eserciti System Design Basics for Backend Developers con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare System Design Basics for Backend Developers?
Non è richiesta alcuna esperienza precedente. System Design Basics for Backend Developers su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Politiche di espulsione della cache»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione System Design Basics for Backend Developers?
Sì. Ogni lezione System Design Basics for Backend Developers include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Pattern di invalidazione della cache
- Integrazione con le CDN e caching edge
- Caching distribuito con Redis
- Politiche di espulsione della cache