Caching Strategies & Layer Placement

// Python 3.10+ Cache-Aside with Mutex Lock (SETNX)
import time, random

class CacheManager:
    def __init__(self, redis_client, db_client):
        self.redis = redis_client
        self.db = db_client

    def get_product(self, product_id: str) -> str:
        cache_key = f"prod:{product_id}"
        val = self.redis.get(cache_key)

        # 1. Cache HIT
        if val is not None: return val

        # 2. Cache MISS: Acquire distributed lock to prevent Thundering Herd
        lock_key = f"lock:{product_id}"
        if self.redis.set(lock_key, "1", nx=True, ex=5):
            try:
                val = self.db.query_product(product_id)
                # Add random TTL jitter (3600s + rand) to prevent Cache Avalanche
                ttl = 3600 + random.randint(0, 300)
                self.redis.set(cache_key, val, ex=ttl)
                return val
            finally:
                self.redis.delete(lock_key)
        else:
            # Another thread is rebuilding cache; sleep 50ms and retry
            time.sleep(0.05)
            return self.get_product(product_id)

// C++20 Cache-Aside with Mutex Lock
#include <string>
#include <thread>
#include <chrono>

class CacheManager {
    RedisClient* redis;
    Database* db;
public:
    std::string getProduct(const std::string& id) {
        std::string key = "prod:" + id;
        std::string val = redis->get(key);
        if (!val.empty()) return val; // Hit

        // Mutex lock prevents thundering herd
        if (redis->setnx("lock:" + id, "1", 5)) {
            val = db->queryProduct(id);
            redis->setex(key, val, 3600 + (rand() % 300));
            redis->del("lock:" + id);
            return val;
        } else {
            std::this_thread::sleep_for(std::chrono::milliseconds(50));
            return getProduct(id);
        }
    }
};

// Java 17+ Redis Cache-Aside with Singleflight Lock
public class CacheManager {
    private final RedisTemplate redis;
    private final ProductRepository db;

    public String getProduct(String id) throws InterruptedException {
        String key = "prod:" + id;
        String val = (String) redis.opsForValue().get(key);
        if (val != null) return val;

        String lockKey = "lock:" + id;
        Boolean acquired = redis.opsForValue().setIfAbsent(lockKey, "1", Duration.ofSeconds(5));
        if (Boolean.TRUE.equals(acquired)) {
            try {
                val = db.findProduct(id);
                int ttl = 3600 + ThreadLocalRandom.current().nextInt(300);
                redis.opsForValue().set(key, val, Duration.ofSeconds(ttl));
                return val;
            } finally {
                redis.delete(lockKey);
            }
        } else {
            Thread.sleep(50);
            return getProduct(id);
        }
    }
}

// Go 1.20+ Singleflight Cache Router
package main

import (
    "golang.org/x/sync/singleflight"
    "time"
)

var sf singleflight.Group

func (c *CacheManager) GetProduct(id string) (string, error) {
    val, err := c.redis.Get("prod:" + id).Result()
    if err == nil { return val, nil } // Cache Hit

    // Singleflight merges 10,000 concurrent calls into 1 DB query
    res, err, _ := sf.Do("prod:"+id, func() (interface{}, error) {
        data, err := c.db.QueryProduct(id)
        if err != nil { return "", err }
        c.redis.Set("prod:"+id, data, 1*time.Hour)
        return data, nil
    })
    return res.(string), err
}

// TypeScript Redis Cache-Aside with Mutex Lock
export class CacheService {
    constructor(private redis: Redis, private db: Database) {}

    async getProduct(id: string): Promise<string> {
        const key = `prod:${id}`;
        const hit = await this.redis.get(key);
        if (hit) return hit;

        // Acquire mutex lock with 5s expiration
        const lock = await this.redis.set(`lock:${id}`, '1', 'NX', 'EX', 5);
        if (lock) {
            try {
                const data = await this.db.findProduct(id);
                const jitter = Math.floor(Math.random() * 300);
                await this.redis.set(key, data, 'EX', 3600 + jitter);
                return data;
            } finally {
                await this.redis.del(`lock:${id}`);
            }
        } else {
            await new Promise(r => setTimeout(r, 50));
            return this.getProduct(id);
        }
    }
}