Importancia del caché en sistemas escalables

En aplicaciones con alta concurrencia, el uso de bases de datos tradicionales puede generar cuellos de botella debido a operaciones de E/S en disco. Redis, como almacén NoSQL en memoria, mitiga estos problemas, pero introduce desafíos como la penetración, sobrecarga y avalancha de caché.

Identificación de los problemas

Penetración de caché: Solicitudes para claves inexistentes en la base de datos que no se almacenan en caché, generando consultas repetidas al almacenamiento subyacente.

Sobrecarga de caché: Cuando una clave en caché expira y múltiples solicitudes concurrentes intentan recargarla simultáneamente, sobrecargando la base de datos.

Avalancha de caché: Expiración masiva de claves o reinicio del servidor de caché, provocando un pico de solicitudes al almacenamiento perisstente.

Estrategias contra la penetración de caché

Una solución efectiva es implementar un filtro de Bloom para bloquear consultas a claves inválidas. Alternativamente, se puede almacenar un valer nulo o predeterminado en caché para claves no halladas, con un tiempo de expiración limitado.

// Ejemplo en Java con valores predeterminados
public Object ConsultarCatalogoProductos() {
    int duracionCache = 25;
    String clave = "productos_catalogo";
    String valorCache = GestorCache.leer(clave);

    if (valorCache == null) {
        valorCache = BaseDatos.obtenerProductos();
        if (valorCache == null) {
            valorCache = "[]"; // Representación de lista vacía
        }
        GestorCache.almacenar(clave, valorCache, duracionCache);
    }
    return valorCache;
}

Manejo de la sobrecarga de caché

El uso de cerrojos distribuidos (mutex) garantiza que solo un proceso recargue la clave expirada. Se puede emplear la operación SETNX en Redis para crear un bloqueo temporal.

// Implementación con cerrojo en Redis
public String RecuperarDatos(String idRecurso) {
    String valor = redis.get(idRecurso);
    if (valor == null) {
        String claveBloqueo = idRecurso + ":lock";
        if (redis.setnx(claveBloqueo, "1", 120) == 1) { // Bloqueo de 2 minutos
            valor = bd.consultar(idRecurso);
            redis.set(idRecurso, valor, 300); // Cache por 5 minutos
            redis.del(claveBloqueo);
        } else {
            Thread.sleep(100);
            return RecuperarDatos(idRecurso); // Reintento
        }
    }
    return valor;
}

Prevención de avalanchas de caché

Para evitar sincronización en expiraciones, se añade un factor aleatorio al tiempo de vida del caché. También se puede emplear un sistema de refresco proactivo en segundo plano.

// Estrategia con marca de actualización diferida
public Object ObtenerConfiguracionSistema() {
    int baseExpiracion = 45;
    String claveConfig = "config_global";
    String claveMarca = claveConfig + ":actualizando";

    String marcaActual = GestorCache.leer(claveMarca);
    String valorConfig = GestorCache.leer(claveConfig);

    if (marcaActual != null) {
        return valorConfig;
    }

    GestorCache.almacenar(claveMarca, "true", baseExpiracion);
    int expiracionExtendida = baseExpiracion + (int)(Math.random() * 30);
    
    EjecutarEnSegundoPlano(() -> {
        Object nuevosDatos = ArchivoConfig.leer();
        GestorCache.almacenar(claveConfig, nuevosDatos, expiracionExtendida);
        GestorCache.eliminar(claveMarca);
    });

    return valorConfig;
}

Complementariamente, se pueden usar múltiples capas de caché o configurar políticas LRU para gestionar la memoria de manera óptima.