漏桶算法vs令牌桶算法，限流到底用哪个？原理+实现深度解析！

最新推荐文章于 2025-07-30 21:01:35 发布

原创最新推荐文章于 2025-07-30 21:01:35 发布 · 515 阅读

12 ·

CC 4.0 BY-SA版权

文章标签：

#网络 #java #服务器

后端专栏收录该内容

6 篇文章

订阅专栏

一、开场白：限流算法选错了，系统分分钟被冲垮？

还记得第一次做限流，领导一句话："你用漏桶还是令牌桶？"我一脸懵："不都是限流吗？有啥区别？"结果一上线，要么限流太严格，要么限流太宽松，系统要么被冲垮要么用户体验差！

今天咱们就聊聊，漏桶算法和令牌桶算法到底有什么区别？怎么选择？一线后端工程师的深度技术解析！

二、限流算法原理，先搞明白再选型

什么是限流？

限流：控制请求流量，防止系统过载，保证系统稳定性。
限流算法：实现限流的具体方法，常见的有漏桶算法和令牌桶算法。

限流的核心目标：

保护系统：防止系统被大量请求冲垮。
保证公平：确保请求能够公平地被处理。
提升体验：在系统过载时，快速拒绝请求，避免长时间等待。

三、漏桶算法原理深度解析

1. 漏桶算法原理

漏桶算法：就像一个固定容量的漏桶，请求以任意速率进入桶中，但桶以固定速率流出请求。

核心特点：

固定速率：桶以固定速率处理请求，无论请求多少。
桶容量限制：桶有固定容量，超过容量就拒绝请求。
平滑流量：能够平滑突发流量，输出稳定的流量。

2. 漏桶算法实现

public class LeakyBucket {
    private long capacity; // 桶容量
    private long rate; // 漏出速率（每秒）
    private long water; // 当前水量
    private long lastTime; // 上次漏水时间
    
    public LeakyBucket(long capacity, long rate) {
        this.capacity = capacity;
        this.rate = rate;
        this.water = 0;
        this.lastTime = System.currentTimeMillis();
    }
    
    public synchronized boolean tryAcquire() {
        long now = System.currentTimeMillis();
        // 计算漏出的水量
        long leaked = (now - lastTime) * rate / 1000;
        water = Math.max(0, water - leaked);
        lastTime = now;
        
        // 如果桶没满，允许请求
        if (water < capacity) {
            water++;
            return true;
        }
        return false;
    }
}

3. 漏桶算法优缺点

优点：

流量平滑：能够平滑突发流量，输出稳定。
实现简单：逻辑简单，容易理解和实现。
内存友好：不需要存储大量令牌。

缺点：

响应延迟：突发流量时，请求需要等待。
无法应对突发：无法快速处理突发流量。

四、令牌桶算法原理深度解析

1. 令牌桶算法原理

令牌桶算法：就像一个固定容量的令牌桶，以固定速率往桶中放入令牌，请求需要获取令牌才能被处理。

核心特点：

固定速率：桶以固定速率生成令牌。
桶容量限制：桶有固定容量，超过容量就丢弃令牌。
突发处理：能够处理突发流量，只要桶中有令牌。

2. 令牌桶算法实现

public class TokenBucket {
    private long capacity; // 桶容量
    private long rate; // 令牌生成速率（每秒）
    private long tokens; // 当前令牌数
    private long lastTime; // 上次生成令牌时间
    
    public TokenBucket(long capacity, long rate) {
        this.capacity = capacity;
        this.rate = rate;
        this.tokens = capacity; // 初始时桶是满的
        this.lastTime = System.currentTimeMillis();
    }
    
    public synchronized boolean tryAcquire() {
        long now = System.currentTimeMillis();
        // 计算生成的令牌数
        long generated = (now - lastTime) * rate / 1000;
        tokens = Math.min(capacity, tokens + generated);
        lastTime = now;
        
        // 如果有令牌，允许请求
        if (tokens > 0) {
            tokens--;
            return true;
        }
        return false;
    }
}

3. 令牌桶算法优缺点

优点：

突发处理：能够处理突发流量，只要桶中有令牌。
响应快速：有令牌时，请求能够快速被处理。
灵活性高：可以设置不同的令牌生成策略。

缺点：

实现复杂：逻辑相对复杂，需要考虑令牌生成。
内存消耗：需要存储令牌信息。

五、漏桶算法 vs 令牌桶算法深度对比

1. 功能对比

特性	漏桶算法	令牌桶算法
流量平滑	✅	❌
突发处理	❌	✅
实现复杂度	简单	复杂
内存消耗	低	高
响应延迟	高	低

2. 适用场景对比

漏桶算法：适合需要平滑流量的场景，如API网关、消息队列。
令牌桶算法：适合需要处理突发流量的场景，如用户接口、秒杀系统。

3. 性能对比

漏桶算法：CPU消耗低，内存消耗低。
令牌桶算法：CPU消耗中等，内存消耗中等。

六、Spring Boot实战实现

1. 漏桶算法实现

@Component
public class LeakyBucketLimiter {
    private final Map<String, LeakyBucket> buckets = new ConcurrentHashMap<>();
    
    public boolean tryAcquire(String key, long capacity, long rate) {
        LeakyBucket bucket = buckets.computeIfAbsent(key, 
            k -> new LeakyBucket(capacity, rate));
        return bucket.tryAcquire();
    }
}

@RestController
public class ApiController {
    @Autowired
    private LeakyBucketLimiter limiter;
    
    @GetMapping("/api/data")
    public ResponseEntity<String> getData() {
        if (limiter.tryAcquire("api", 100, 10)) { // 容量100，速率10/s
            return ResponseEntity.ok("success");
        }
        return ResponseEntity.status(429).body("rate limited");
    }
}

2. 令牌桶算法实现

@Component
public class TokenBucketLimiter {
    private final Map<String, TokenBucket> buckets = new ConcurrentHashMap<>();
    
    public boolean tryAcquire(String key, long capacity, long rate) {
        TokenBucket bucket = buckets.computeIfAbsent(key, 
            k -> new TokenBucket(capacity, rate));
        return bucket.tryAcquire();
    }
}

@RestController
public class UserController {
    @Autowired
    private TokenBucketLimiter limiter;
    
    @PostMapping("/user/order")
    public ResponseEntity<String> createOrder() {
        if (limiter.tryAcquire("order", 50, 5)) { // 容量50，速率5/s
            return ResponseEntity.ok("order created");
        }
        return ResponseEntity.status(429).body("rate limited");
    }
}