Request Hedging / Cache debouncing

 package com.example.personal;

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class RequestHedgingCache {
    private static final ConcurrentHashMap<String, String> cache = new ConcurrentHashMap<>();
    private static final ConcurrentHashMap<String, Semaphore> locks = new ConcurrentHashMap<>();
    private static final ConcurrentHashMap<String, Integer> dbTracker = new ConcurrentHashMap<>(); // Track which user fetched from DB

    public static String fetchBookData(int userID, String bookID) throws InterruptedException {
        Semaphore lock = locks.computeIfAbsent(bookID, k -> new Semaphore(1));
        System.out.println(lock);
        // Try to acquire lock (First user gets access to fetch from DB)
        if (lock.tryAcquire()) {
            try {
                // Double-check cache **after acquiring the lock** to avoid duplicate cache misses
                String cachedData = cache.get(bookID);
                if (cachedData != null) {
                    return "User " + userID + " - Cached Response (After Lock Acquisition): " + cachedData;
                }

                // 🚀 **Only First User Logs This Cache Miss**
                System.out.println("🚨 Cache Miss! User " + userID + " is fetching from DB for book ID: " + bookID);

                // Simulated DB fetch
                String dbData = fetchFromDB(bookID);
                cache.put(bookID, dbData); // Update cache
                dbTracker.put(bookID, userID); // Track who fetched from DB

                return "User " + userID + " - Fetched from DB: " + dbData;
            } finally {
                System.out.println("✅ User " + userID + " finished DB fetch. Releasing lock for waiting users.");
                lock.release(); // Allow waiting threads to proceed
            }
        } else {
            // Other users immediately wait for cache update **without checking cache first**
            System.out.println("⏳ User " + userID + " is waiting for cache update..."+lock);
            lock.acquire();  // Block until first user finishes fetching
            System.out.println("🔓 User " + userID + " is released. Fetching from cache...");
            lock.release();  // Ensure proper semaphore behavior
            return "User " + userID + " - Hedged Request (Got Cached Data): " + cache.get(bookID) +
                    " (Fetched by User " + dbTracker.get(bookID) + ")";
        }
    }

    private static String fetchFromDB(String bookID) throws InterruptedException {
        Thread.sleep(1000); // Simulate DB delay
        return "BookData-" + bookID;
    }

    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(10);
        AtomicInteger userID = new AtomicInteger(1);

        for (int i = 0; i < 10; i++) {
            final String bookID = "12345"; // All requests search for the same book
            executor.execute(() -> {
                try {
                    System.out.println(fetchBookData(userID.getAndIncrement(), "12345"));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        executor.shutdown();
    }
}