A rate limiter for a payment gateway

public final class Limiter {
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition ready = lock.newCondition();
    private final double ratePerNano, burst;
    private double tokens;
    private long last;          // System.nanoTime()
 
    public Limiter(double perSecond, double burst) {
        this.ratePerNano = perSecond / 1_000_000_000d;
        this.burst = burst;
        this.tokens = burst;
        this.last = System.nanoTime();
    }
 
    private void advance(long now) {          // caller holds lock
        long elapsed = now - last;            // subtraction handles wraparound
        if (elapsed <= 0) return;
        tokens = Math.min(burst, tokens + elapsed * ratePerNano);
        last = now;
    }
 
    public boolean tryAcquire() {
        lock.lock();
        try {
            advance(System.nanoTime());
            if (tokens < 1) return false;
            tokens -= 1;
            return true;
        } finally { lock.unlock(); }
    }
 
    public void acquire() throws InterruptedException {
        long waitNanos;
        lock.lock();
        try {
            advance(System.nanoTime());
            tokens -= 1;                       // reserve, may go negative
            if (tokens >= 0) return;
            waitNanos = (long) (-tokens / ratePerNano);
        } finally { lock.unlock(); }
 
        try {
            TimeUnit.NANOSECONDS.sleep(waitNanos);
        } catch (InterruptedException e) {
            lock.lock();
            try { tokens += 1; } finally { lock.unlock(); }   // hand it back
            throw e;
        }
    }
}

type Limiter struct {
	mu     sync.Mutex
	tokens float64
	burst  float64
	rate   float64   // tokens per second
	last   time.Time // when tokens was last brought up to date
}
 
func NewLimiter(rate, burst int) *Limiter {
	return &Limiter{
		tokens: float64(burst),
		burst:  float64(burst),
		rate:   float64(rate),
		last:   time.Now(),
	}
}
 
// advance brings the bucket up to `now`. Caller must hold l.mu.
func (l *Limiter) advance(now time.Time) {
	elapsed := now.Sub(l.last)
	if elapsed <= 0 {
		return // a non-monotonic clock must never remove tokens
	}
	l.tokens += elapsed.Seconds() * l.rate
	if l.tokens > l.burst {
		l.tokens = l.burst
	}
	l.last = now
}
 
func (l *Limiter) Allow() bool {
	l.mu.Lock()
	defer l.mu.Unlock()
 
	l.advance(time.Now())
	if l.tokens < 1 {
		return false
	}
	l.tokens--
	return true
}

func (l *Limiter) Wait(ctx context.Context) error {
	l.mu.Lock()
	l.advance(time.Now())
	if l.tokens >= 1 {
		l.tokens--
		l.mu.Unlock()
		return nil
	}
	// Reserve the token now, and work out when it will have accrued.
	deficit := 1 - l.tokens
	l.tokens -= 1 // may go negative: this caller owns a future token
	delay := time.Duration(deficit / l.rate * float64(time.Second))
	l.mu.Unlock()
 
	t := time.NewTimer(delay)
	defer t.Stop()
	select {
	case <-t.C:
		return nil
	case <-ctx.Done():
		// Hand the reservation back, or a cancelled caller starves the next one.
		l.mu.Lock()
		l.tokens++
		l.mu.Unlock()
		return ctx.Err()
	}
}

import threading, time
 
class Limiter:
    def __init__(self, rate: float, burst: float) -> None:
        self._rate = rate
        self._burst = burst
        self._tokens = burst
        self._last = time.monotonic()      # never time.time()
        self._lock = threading.Lock()
 
    def _advance(self, now: float) -> None:  # caller holds the lock
        elapsed = now - self._last
        if elapsed <= 0:
            return
        self._tokens = min(self._burst, self._tokens + elapsed * self._rate)
        self._last = now
 
    def allow(self) -> bool:
        with self._lock:
            self._advance(time.monotonic())
            if self._tokens < 1:
                return False
            self._tokens -= 1
            return True
 
    def wait(self, timeout: float | None = None) -> bool:
        with self._lock:
            self._advance(time.monotonic())
            self._tokens -= 1                       # reserve
            if self._tokens >= 0:
                return True
            delay = -self._tokens / self._rate
        if timeout is not None and delay > timeout:
            with self._lock:
                self._tokens += 1                   # hand it back
            return False
        time.sleep(delay)                           # lock released
        return True

import asyncio
 
class AsyncLimiter:
    def __init__(self, rate: float, burst: float) -> None:
        self._rate, self._burst = rate, burst
        self._tokens = burst
        self._last = asyncio.get_event_loop().time()
        self._lock = asyncio.Lock()
 
    async def acquire(self) -> None:
        async with self._lock:
            now = asyncio.get_running_loop().time()
            elapsed = now - self._last
            if elapsed > 0:
                self._tokens = min(self._burst, self._tokens + elapsed * self._rate)
                self._last = now
            self._tokens -= 1
            delay = 0.0 if self._tokens >= 0 else -self._tokens / self._rate
        if delay:
            await asyncio.sleep(delay)              # lock released first