说说什么是令牌桶算法

        令牌以固定速率生成
              ↓
    ┌─────────────────┐
    │    令牌桶        │ ←── 桶容量固定（如容量=10）
    │  [○][○][○][○]   │     当前令牌数 ≤ 容量
    └────────┬────────┘
             ↓ 请求尝试获取令牌
    ┌─────────────────┐
    │   请求处理       │ ←── 拿到令牌：通过
    │   请求被拒绝     │ ←── 没令牌：限流/等待
    └─────────────────┘

class TokenBucket {
    long capacity;          // 桶容量
    long tokens;            // 当前令牌数
    long lastTime;          // 上次更新时间
    long rate;              // 产生速率（令牌/毫秒）
    
    synchronized boolean tryAcquire() {
        long now = System.currentTimeMillis();
        // 1. 计算这段时间产生的令牌数，并加到桶中（不超过容量）
        tokens = Math.min(capacity, tokens + (now - lastTime) * rate);
        lastTime = now;
        
        // 2. 尝试获取令牌
        if (tokens > 0) {
            tokens--;
            return true;    // 获取成功，请求通过
        }
        return false;       // 获取失败，被限流
    }
}

假设：容量=10，速率=1 token/sec

时间线：
t0: 桶满10个令牌，突然来了15个请求
    → 前10个请求瞬间通过（突发）
    → 后5个请求按1个/秒匀速通过
    → 长期平均速率 = 1 req/sec

漏桶示意图（强制匀速）：
    请求流入 → [ 漏桶/队列 ] → 匀速流出（固定速率处理）
                  ↑
              桶满则溢出（拒绝）

public class TokenBucket {
    private final long capacity;      // 桶容量
    private final long rate;          // 每秒产生令牌数
    private double tokens;            // 当前令牌数（用double支持小数）
    private long lastTimestamp;       // 上次更新时间（秒）
    
    public TokenBucket(long capacity, long rate) {
        this.capacity = capacity;
        this.rate = rate;
        this.tokens = capacity;       // 初始满桶
        this.lastTimestamp = System.currentTimeMillis() / 1000;
    }
    
    public synchronized boolean allowRequest() {
        long now = System.currentTimeMillis() / 1000;
        // 计算新产生的令牌
        tokens = Math.min(capacity, tokens + (now - lastTimestamp) * rate);
        lastTimestamp = now;
        
        if (tokens >= 1) {
            tokens--;
            return true;
        }
        return false;
    }
}

import com.google.common.util.concurrent.RateLimiter;

// 创建：每秒产生2个令牌（平滑突发）
RateLimiter limiter = RateLimiter.create(2.0);

// 阻塞获取（拿不到就等待）
limiter.acquire();  

// 非阻塞尝试（立即返回是否成功）
if (limiter.tryAcquire()) {
    // 处理请求
} else {
    // 被限流，返回503或降级
}

-- 令牌桶限流 Lua 脚本（原子操作）
local key = KEYS[1]           -- 桶的key
local capacity = tonumber(ARGV[1])
local rate = tonumber(ARGV[2]) 
local now = tonumber(ARGV[3]) -- 当前时间戳（毫秒）
local requested = tonumber(ARGV[4]) -- 需要令牌数

local fill_time = capacity / rate
local ttl = math.floor(fill_time * 2)

-- 获取当前状态
local last_tokens = redis.call('get', key .. ':tokens')
local last_updated = redis.call('get', key .. ':last_updated')

if last_tokens == false then
    last_tokens = capacity
    last_updated = 0
else
    last_tokens = tonumber(last_tokens)
    last_updated = tonumber(last_updated)
end

-- 计算新令牌数
local delta = math.max(0, now - last_updated)
local filled_tokens = math.min(capacity, last_tokens + (delta * rate / 1000))
local allowed = filled_tokens >= requested

local new_tokens = filled_tokens
if allowed then
    new_tokens = filled_tokens - requested
end

-- 更新状态
redis.call('setex', key .. ':tokens', ttl, new_tokens)
redis.call('setex', key .. ':last_updated', ttl, now)

return allowed and 1 or 0