Defensa contra la estampida de solicitudes
Aprenda cómo se producen las estampidas de caché cuando caducan las claves populares y las técnicas para prevenirlas: agrupación de solicitudes, bloqueos, recomputación anticipada y TTL con jitter.
Defensa contra la estampida de solicitudes es una lección gratuita de Caching Strategies: Redis + CDN + Edge Computing en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Caching Strategies: Redis + CDN + Edge Computing, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Caching Strategies: Redis + CDN + Edge Computing incluye 4 lecciones en total.
Partes de esta lección aún no han sido traducidas y se muestran en inglés.
The Thundering Herd Problem
When a hot cache key expires, every concurrent request misses at once and rushes the origin together. This cache stampede (or thundering herd) can overwhelm the database in an instant.
Why It Is Dangerous
A single popular item serving 10,000 requests/second normally hits the cache. The moment it expires, those 10,000 requests all hit the database simultaneously, often causing a spike that takes the origin down.
Cause: Synchronized Expiry
The root cause is many keys (or many requests on one key) expiring at the same moment. The fix strategies all aim to spread or serialize the resulting recomputation.
Fix 1: Request Coalescing
Let only the first request recompute the value; everyone else waits for that result. This is also called single-flight.
in_flight = {}
def get(key, compute):
if key in in_flight:
return 'waiting for in-flight result'
in_flight[key] = True
return compute()
print(get('hot', lambda: 'computed once'))Fix 2: Mutex Lock
Use a distributed lock (e.g. a Redis key with NX) so only one process recomputes. Others briefly serve stale data or retry after a short wait.
lock = None
def acquire_lock(holder):
global lock
if lock is None:
lock = holder
return True
return False
print(acquire_lock('worker-1'))
print(acquire_lock('worker-2'))Fix 3: Jittered TTL
Add randomness to each entry's TTL so they do not all expire together. A base TTL plus random jitter spreads recomputation over time.
import random
base_ttl = 300
jitter = random.randint(0, 60)
print('TTL for this entry:', base_ttl + jitter, 'seconds')Fix 4: Early Recomputation
Refresh a value before it expires. When an entry is close to its TTL, a background task (or a probabilistic check) recomputes it so it never actually goes cold for users.
Probabilistic Early Expiration
A clever trick: as a key nears expiry, give each request a small, growing probability of recomputing early. One lucky request refreshes the value while others still serve the cached copy.
import random
time_left = 5
beta = 1.0
should_refresh = random.random() < (1 / max(time_left, 1)) * beta
print('Refresh early?', should_refresh)Fix 5: Serve Stale While Revalidating
Return the expired value immediately while a background job fetches fresh data. Users get a fast (slightly stale) response and the origin sees only one refresh request.
Combining Defenses
Real systems layer these: jittered TTLs to avoid synchronized expiry, plus coalescing or a lock to serialize the inevitable misses, plus stale-while-revalidate for the best user experience.
Watch for Cache Penetration Too
A related issue is penetration: requests for keys that never exist always miss and hit the origin. Cache negative results (or use a bloom filter) so missing keys are also absorbed.
Quick Check
Which technique prevents a cache stampede by ensuring only one request recomputes the value while the rest wait for that result?
Recap
You learned to defend against the thundering herd:
- Stampedes happen when hot keys expire and many requests miss at once.
- Coalescing and locks serialize recomputation.
- Jittered TTLs and early recomputation spread the load.
- Stale-while-revalidate keeps responses fast.
Combine these to keep your origin safe under load.
Preguntas frecuentes
¿La lección «Defensa contra la estampida de solicitudes» es gratis?
Sí — el texto completo de «Defensa contra la estampida de solicitudes» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Caching Strategies: Redis + CDN + Edge Computing, actualiza a CoddyKit PRO. El curso de Caching Strategies: Redis + CDN + Edge Computing incluye 4 lecciones en total.
¿Qué aprenderé en «Defensa contra la estampida de solicitudes»?
Aprenda cómo se producen las estampidas de caché cuando caducan las claves populares y las técnicas para prevenirlas: agrupación de solicitudes, bloqueos, recomputación anticipada y TTL con jitter. Practicas Caching Strategies: Redis + CDN + Edge Computing con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Caching Strategies: Redis + CDN + Edge Computing?
No se requiere experiencia previa. Caching Strategies: Redis + CDN + Edge Computing en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Defensa contra la estampida de solicitudes»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Caching Strategies: Redis + CDN + Edge Computing?
Sí. Cada lección de Caching Strategies: Redis + CDN + Edge Computing incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Patrones comunes de almacenamiento en caché
- Estrategias de invalidación de caché
- Políticas de desalojo de caché
- Defensa contra la estampida de solicitudes