Design: Distributed Cache

// Redis Cluster architecture
//
//  Application Instances
//    │  │  │
//    ▼  ▼  ▼
// ┌──────────────────────────────────────────┐
// │           Redis Cluster                    │
// │                                            │
// │  Shard 1         Shard 2         Shard 3   │
// │  slots 0-5460    slots 5461-10922 slots 10923-16383
// │  ┌────────┐     ┌────────┐     ┌────────┐ │
// │  │Master 1│     │Master 2│     │Master 3│ │
// │  └───┬────┘     └───┬────┘     └───┬────┘ │
// │      │              │              │       │
// │  ┌───▼────┐     ┌───▼────┐     ┌───▼────┐ │
// │  │Replica 1│     │Replica 2│     │Replica 3│ │
// │  └────────┘     └────────┘     └────────┘ │
// └──────────────────────────────────────────┘
//
// Key routing: slot = CRC16(key) % 16384
// Client knows slot→node mapping → direct connection
// If wrong node: MOVED redirect → client updates mapping

// Thundering herd problem
// Popular key "trending_posts" expires at 10:00:00
// 1000 requests arrive at 10:00:01 → all see cache miss → all hit DB
// DB overwhelmed!

// Solution 1: Mutex lock (only one request refreshes cache)
public List<Post> getTrendingPosts() {
    List<Post> cached = redis.get("trending_posts");
    if (cached != null) return cached;

    // Try to acquire lock
    boolean locked = redis.setIfAbsent("lock:trending", "1", Duration.ofSeconds(10));
    if (locked) {
        // This request refreshes cache
        List<Post> posts = db.getTrendingPosts();
        redis.set("trending_posts", posts, Duration.ofMinutes(5));
        redis.delete("lock:trending");
        return posts;
    } else {
        // Other requests wait briefly and retry from cache
        Thread.sleep(100);
        return redis.get("trending_posts");
    }
}

// Solution 2: Staggered TTL (add random jitter)
int ttl = 300 + ThreadLocalRandom.current().nextInt(60); // 300-360 seconds
// Keys expire at different times → no simultaneous expiry

// Hot key: replicate to multiple nodes
// key "celebrity:123" gets 100K reads/sec → overwhelms one shard
// Solution: read from replicas, or create copies: celebrity:123#1, #2, #3