System Architecture Principles Questions

public class CircuitBreaker {
    enum State { CLOSED, OPEN, HALF_OPEN }
    private State state = State.CLOSED;

    // Config
    private int failureThreshold;           // consecutive failures
    private double errorRateThreshold;      // e.g., 0.5 for 50%
    private int rollingWindowMillis;
    private int minRequests;                // only evaluate error rate after this many requests
    private long openTimeoutMillis;         // how long to stay OPEN before HALF_OPEN
    private long lastStateChange = now();

    // Metrics (sliding window)
    private SlidingWindow window; // holds request count, failures, latencies

    public synchronized <T> T call(Supplier<T> remoteCall) throws Failure {
        if(state == State.OPEN) {
            if(now() - lastStateChange >= openTimeoutMillis) transitionToHalfOpen();
            else throw new ShortCircuitException();
        }

        try {
            // optionally enforce timeouts
            T result = remoteCall.get();
            onSuccess();
            return result;
        } catch(Exception e) {
            onFailure(e);
            throw e;
        }
    }

    private void onSuccess() {
        window.recordSuccess();
        if(state == State.HALF_OPEN) transitionToClosed();
    }

    private void onFailure(Exception e) {
        window.recordFailure();
        evaluateState();
    }

    private void evaluateState() {
        if(state == State.CLOSED) {
            if(window.consecutiveFailures() >= failureThreshold) open();
            else if(window.totalRequests() >= minRequests && window.errorRate() >= errorRateThreshold) open();
            else if(window.avgLatency() > latencyThresholdMillis) open();
        } else if(state == State.HALF_OPEN) {
            if(window.probeFailures() > 0) open();
        }
    }
    // transitions: open(), transitionToHalfOpen(), transitionToClosed()
}

import java.util.concurrent.*;
import java.util.concurrent.locks.ReentrantLock;

public class TokenBucketLimiter {
    // Holds per-user buckets
    private final ConcurrentMap<String, TokenBucket> buckets = new ConcurrentHashMap<>();
    private final double defaultRefillPerSecond;
    private final double defaultCapacity;

    public TokenBucketLimiter(double refillPerSecond, double capacity) {
        this.defaultRefillPerSecond = refillPerSecond;
        this.defaultCapacity = capacity;
    }

    // Ensure bucket exists (thread-safe) and try to consume 1 token
    public boolean allowRequest(String userId) {
        TokenBucket b = buckets.computeIfAbsent(userId,
            id -> new TokenBucket(defaultRefillPerSecond, defaultCapacity));
        return b.tryConsume(1);
    }

    // Optionally create bucket with custom params
    public boolean allowRequest(String userId, double refillPerSecond, double capacity) {
        TokenBucket b = buckets.computeIfAbsent(userId,
            id -> new TokenBucket(refillPerSecond, capacity));
        return b.tryConsume(1);
    }

    // Simple per-user token bucket
    static class TokenBucket {
        private final double capacity;
        private final double refillPerSecond;
        private double tokens;
        private long lastRefillNanos;
        private final ReentrantLock lock = new ReentrantLock();

        TokenBucket(double refillPerSecond, double capacity) {
            this.capacity = capacity;
            this.refillPerSecond = refillPerSecond;
            this.tokens = capacity; // start full
            this.lastRefillNanos = System.nanoTime();
        }

        // Try to consume 'amount' tokens. Returns true if allowed.
        boolean tryConsume(double amount) {
            lock.lock();
            try {
                refill();
                if (tokens >= amount) {
                    tokens -= amount;
                    return true;
                } else {
                    return false;
                }
            } finally {
                lock.unlock();
            }
        }

        // Refill tokens based on elapsed time
        private void refill() {
            long now = System.nanoTime();
            long elapsedNanos = now - lastRefillNanos;
            if (elapsedNanos <= 0) return;
            double added = (elapsedNanos / 1e9) * refillPerSecond;
            if (added > 0) {
                tokens = Math.min(capacity, tokens + added);
                lastRefillNanos = now;
            }
        }
    }
}