数据结构与算法|【限流算法】通俗易懂的Java常见限流算法

id="article_content" class="article_content clearfix" style="height: 2000px; overflow: hidden;"> id="content_views" class="markdown_views prism-atom-one-dark">

一、漏桶算法

1.漏桶算法的思想和原理

1.固定容量的漏桶：系统维护一个固定容量的漏桶，用来存放请求。

2.请求入桶：当一个请求到达系统时，相当于将水倒入漏桶。如果漏桶已满，多余的请求会被丢弃或拒绝。

3.恒定速率的出桶：漏桶以恒定的速率处理请求，就像漏斗中的水稳定地漏出一样。

4.平滑流量：通过漏桶的出水速率，可以平滑流入系统的请求，避免突发流量。

5.限流判断：当一个请求到达时，会检查漏桶是否已满，如果漏桶已满，则触发限流机制，拒绝请求。

漏桶算法的实现步骤是，先声明一个队列用来保存请求，这个队列相当于漏斗，当队列容量满了之后就放弃新来的请求，然后重新声明一个线程定期（指定速率）从任务队列中获取一个或多个任务进行执行，这样就实现了漏桶算法。

优点：可以有效控制流量，避免突发请求的冲击，保持系统稳定性；

缺点：可能会影响请求响应时间，且不使用大并发量的请求系统；

2.具体实现

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;

public class LeakyBucket {
    private final long capacity; // 桶容量
    private final long rate; // 漏水速率
    private long water; // 当前水量
    private long lastLeakTime; // 上一次漏水时间
    private final AtomicLong requestCount; // 请求计数

    public LeakyBucket(long capacity, long rate) {
        this.capacity = capacity;
        this.rate = rate;
        this.water = 0;
        this.lastLeakTime = System.currentTimeMillis();
        this.requestCount = new AtomicLong(0);

        //以固定的速率漏水
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
        scheduler.scheduleAtFixedRate(this::leakWater, 0, 1, TimeUnit.SECONDS);
    }

    //限流
    public synchronized boolean allowRequest() {
        long currentTime = System.currentTimeMillis();
        long elapsedTime = currentTime - lastLeakTime;
        water = Math.max(0, water - elapsedTime * rate); // 漏水
        lastLeakTime = currentTime;

        if (water < capacity) {
            water++;
            requestCount.incrementAndGet();
            return true; // 请求通过
        }
        return false; // 漏桶已满，限流
    }

    public long getRequestCount() {
        return requestCount.get();
    }

    //以固定速率漏水
    private synchronized void leakWater() {
        long currentTime = System.currentTimeMillis();
        long elapsedTime = currentTime - lastLeakTime;
        water = Math.max(0, water - elapsedTime * rate); // 漏水
        lastLeakTime = currentTime;
    }

    public static void main(String[] args) {
        // 创建一个容量为 10，速率为 2/S的漏桶
        LeakyBucket leakyBucket = new LeakyBucket(10, 2);

        // 模拟请求
        for (int i = 0; i < 20; i++) {
            boolean allowed = leakyBucket.allowRequest();
            if (allowed) {
                System.out.println("Request " + (i + 1) + ": Allowed");
            } else {
                System.out.println("Request " + (i + 1) + ": Limited");
            }
        }

        // 输出总请求数
        System.out.println("Total requests: " + leakyBucket.getRequestCount());
    }
}

 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

二、令牌桶算法

1.令牌桶算法流程:

1.放入令牌到桶：按照固定的速率被放入令牌桶中，比如每秒放5个、10个、100个令牌到桶中。

2.获取令牌：所有的请求在处理之前都需要拿到一个可用的令牌才会被处理。

3.令牌桶满了拒绝：桶中最多能放1000个令牌，当桶满时，就不能继续放入了，新添加的令牌要么被丢弃，要么就直接拒绝。

2.可以根据需求调整令牌生成速率和令牌桶的容量，以适应不同的流星控制需求。

缺点：
1.不适合瞬时突发流量，令牌桶算法可能无法处理突然涌入的大量请求，因为令牌桶的令牌生成速率是固定的。

2.如果请求需要等待令牌桶中的令牌，可能会导致一些请求的响应时间增加。

【限流算法】通俗易懂的Java常见限流算法

一、漏桶算法

1.漏桶算法的思想和原理

2.具体实现

二、令牌桶算法

1.令牌桶算法流程:

2.具体实现

2.1 编程实现

2.2 使用 Google 开源的 guava 包

（1）导入依赖

（2）代码实现

三、Nginx限流

四、Redis+Lua限流

1.Lua介绍

2.Lua优势：

3.具体实现：

（1）编写Lua脚本（将其放在resources/scripts/redis目录下）:

（2）代码实现:

评论记录：