Concurrency
in LLD

class BankAccount {
    private double              balance = 0;
    private final ReentrantLock lock = new ReentrantLock(true); // fair=true

    // Basic lock — ALWAYS unlock in finally
    public void deposit(double amount) {
        lock.lock();
        try     { balance += amount; }
        finally { lock.unlock(); }  // ← never skip this
    }

    // tryLock — non-blocking, returns false if unavailable
    public boolean tryDeposit(double amount) {
        if (lock.tryLock()) {
            try     { balance += amount; return true; }
            finally { lock.unlock(); }
        }
        return false;
    }

    // tryLock with timeout — blocks at most N ms
    public boolean tryDepositTimeout(double amount, long ms)
            throws InterruptedException {
        if (lock.tryLock(ms, TimeUnit.MILLISECONDS)) {
            try     { balance += amount; return true; }
            finally { lock.unlock(); }
        }
        return false;  // Timeout — didn't acquire
    }
}

class ConfigCache {
    private final Map<String,String> cache  = new HashMap<>();
    private final ReadWriteLock        rwLock = new ReentrantReadWriteLock();
    private final Lock                 rLock  = rwLock.readLock();
    private final Lock                 wLock  = rwLock.writeLock();

    // ✅ MANY threads can read simultaneously
    public String get(String key) {
        rLock.lock();
        try     { return cache.get(key); }
        finally { rLock.unlock(); }
    }

    // ✅ EXCLUSIVE — blocks all readers + other writers
    public void put(String key, String val) {
        wLock.lock();
        try     { cache.put(key, val); }
        finally { wLock.unlock(); }
    }

    // Double-checked pattern — read fast path, write fallback
    public String computeIfAbsent(String key, Function<String,String> fn) {
        rLock.lock();                             // 1. Try read (fast path)
        try { if (cache.get(key) != null) return cache.get(key); }
        finally { rLock.unlock(); }
        wLock.lock();                             // 2. Write lock
        try {
            if (cache.get(key) != null) return cache.get(key); // 3. Double-check
            String v = fn.apply(key);
            cache.put(key, v); return v;
        } finally { wLock.unlock(); }
    }
}

class LogPipeline {
    // LinkedBlockingQueue: bounded, separate head/tail locks — high throughput
    private final BlockingQueue<LogEvent> queue =
        new LinkedBlockingQueue<>(1000); // Bounded — backpressure!
    private volatile boolean running = true;

    // PRODUCER — any app thread calls this
    public void log(String level, String msg) {
        try {
            queue.put(new LogEvent(level, msg)); // Blocks if queue full (backpressure)
        } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
    }

    public boolean tryLog(String level, String msg) {
        return queue.offer(new LogEvent(level, msg)); // Non-blocking, drops if full
    }

    // CONSUMER — background thread drains queue
    private void consume() {
        while (running || !queue.isEmpty()) {
            try {
                LogEvent e = queue.poll(100, TimeUnit.MILLISECONDS); // timeout: re-check 'running'
                if (e != null) writeToSink(e);
            } catch (InterruptedException e) { Thread.currentThread().interrupt(); break; }
        }
    }
}

class BoundedBuffer<T> {
    private final Object[]      buf;
    private int                  count=0, put=0, take=0;
    private final ReentrantLock lock     = new ReentrantLock();
    private final Condition     notFull  = lock.newCondition();
    private final Condition     notEmpty = lock.newCondition();

    public void put(T item) throws InterruptedException {
        lock.lock();
        try {
            while (count == buf.length) notFull.await();  // ← WHILE not IF! (spurious wakeups)
            buf[put] = item; put = (put+1)%buf.length; count++;
            notEmpty.signal();  // Wake one consumer
        } finally { lock.unlock(); }
    }

    public T take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0) notEmpty.await();         // ← WHILE not IF!
            T item = (T) buf[take]; buf[take]=null; take=(take+1)%buf.length; count--;
            notFull.signal();   // Wake one producer
            return item;
        } finally { lock.unlock(); }
    }
}

class DBConnectionPool {
    private final Semaphore         sem;
    private final Queue<Connection>  pool = new ConcurrentLinkedQueue<>();

    public DBConnectionPool(int max) {
        sem = new Semaphore(max, true);  // fair=true: FIFO, no starvation
        for (int i=0; i<max; i++) pool.offer(createConnection());
    }

    public Connection acquire() throws InterruptedException {
        sem.acquire();         // Blocks until a slot is free
        return pool.poll();
    }

    public Connection acquire(long ms) throws InterruptedException {
        if (!sem.tryAcquire(ms, TimeUnit.MILLISECONDS))
            throw new TimeoutException("No connection in "+ms+"ms");
        return pool.poll();
    }

    public void release(Connection c) {
        pool.offer(c);
        sem.release();         // Signal one slot free → unblocks next waiter
    }
}

class TokenBucketRateLimiter {
    private final long   capacity;
    private final double refillRatePerMs;
    private double       tokens;
    private long         lastRefill;

    public TokenBucketRateLimiter(long capacity, long rps) {
        this.capacity        = capacity;
        this.refillRatePerMs = rps / 1000.0;
        this.tokens          = capacity;   // Start full
        this.lastRefill      = System.currentTimeMillis();
    }

    private void refill() {
        long now = System.currentTimeMillis();
        tokens = Math.min(capacity, tokens + (now - lastRefill) * refillRatePerMs);
        lastRefill = now;
    }

    // Non-blocking — returns false if rate exceeded
    public synchronized boolean tryAcquire() {
        refill();
        if (tokens >= 1) { tokens--; return true; }
        return false;
    }

    // Blocking — waits until token available
    public synchronized void acquire() throws InterruptedException {
        while (true) {
            refill();
            if (tokens >= 1) { tokens--; return; }
            long waitMs = (long) Math.ceil((1-tokens)/refillRatePerMs);
            wait(waitMs);
        }
    }
}

// Per-user limiter — each user gets own bucket
class UserRateLimiter {
    private final ConcurrentHashMap<String, TokenBucketRateLimiter> buckets
        = new ConcurrentHashMap<>();
    private final Map<Tier,Long> limits = Map.of(
        Tier.FREE,10L, Tier.PRO,100L, Tier.ENTERPRISE,1000L);

    public boolean tryAcquire(String userId, Tier tier) {
        return buckets.computeIfAbsent(userId,
            k -> new TokenBucketRateLimiter(limits.get(tier)*10, limits.get(tier))
        ).tryAcquire();
    }
}