Redis Cache Stampede: Como Prevenir com Bloqueio e Jitter de TTL

O que é Cache Stampede?

Cache stampede (ou avalanche de cache) ocorre quando uma chave de cache popular expira e múltiplas requisições simultâneas tentam regenerar o cache ao mesmo tempo, sobrecarregando o banco de dados ou serviço de backend.

Estratégias de Prevenção

1. Bloqueio Mutex (Mutex Lock)

Use um bloqueio distribuído para garantir que apenas um processo recalcule o cache:

import redis
import time

r = redis.Redis()

def get_data(key):
    # Tenta obter do cache
    data = r.get(key)
    if data is not None:
        return data
    
    # Tenta adquirir bloqueio
    lock_key = f"lock:{key}"
    if r.setnx(lock_key, "locked"):
        # Define expiração do bloqueio
        r.expire(lock_key, 10)
        try:
            # Recalcula dados
            data = expensive_computation()
            r.setex(key, 300, data)
            return data
        finally:
            r.delete(lock_key)
    else:
        # Espera e tenta novamente
        time.sleep(0.1)
        return get_data(key)

2. Recomputação Probabilística Antecipada

Recalcula o cache antes da expiração com base em probabilidade:

import random

def should_recompute(ttl, beta=1.0):
    """Decide probabilisticamente se deve recomputar"""
    return random.random() < (1 - ttl / (beta * 300))

3. Jitter de TTL

Adicione variação aleatória ao TTL para evitar expirações simultâneas:

import random

base_ttl = 300
jitter = random.uniform(0.9, 1.1)  # ±10%
ttl = int(base_ttl * jitter)
r.setex(key, ttl, data)

Comparação de Estratégias

Estratégia	Complexidade	Eficácia	Latência
Mutex Lock	Média	Alta	Média
Recomputação Probabilística	Baixa	Média	Baixa
Jitter de TTL	Muito Baixa	Alta	Nenhuma

Conclusão

Combine múltiplas estratégias para máxima proteção. Use jitter de TTL como prevenção básica e mutex lock para dados críticos.