Java高并发系统限流算法的实现

Java高并发系统限流算法的实现攻略

什么是限流算法

限流算法是指限制一个系统的并发数或者流量的算法，一旦超出限制就拒绝服务或者延迟处理。

为什么需要限流算法

在高并发系统中，如果没有限流算法来限制流量或者并发数，就会容易出现系统崩溃或瘫痪的情况。

限流算法分类

1. 固定时间窗口算法
2. 滑动时间窗口算法
3. 漏桶算法
4. 令牌桶算法

固定时间窗口限流算法

固定时间窗口限流算法的基本思路是在单位时间内设置一个最大的并发数或者流量，一旦超出这个限制，就拒绝服务或者延迟处理。

固定时间窗口限流算法的实现步骤：

1. 获取当前时间戳
2. 计算当前时间戳的时间窗口大小
3. 从时间戳中获取当前时间窗口的起始位置
4. 统计当前时间窗口内的请求量或者流量
5. 如果请求量或者流量超过限制，则进行限流处理

下面是一个Java实现固定时间窗口限流算法的示例：

public class FixedWindowLimiter {
    private final LinkedList<Long> requestList = new LinkedList<>();
    private final int limit;
    private final long interval;

    public FixedWindowLimiter(int limit, long interval) {
        this.limit = limit;
        this.interval = interval;
    }

    public synchronized boolean tryAcquire() {
        long now = System.currentTimeMillis();
        long windowStart = now - interval;
        if (requestList.isEmpty()) {
            requestList.addLast(now);
            return true;
        } else {
            long earliestRequest = requestList.getFirst();
            if (earliestRequest > windowStart + interval) {
                requestList.clear();
            }
            if (requestList.size() >= limit) {
                return false;
            } else {
                requestList.addLast(now);
                return true;
            }
        }
    }
}

漏桶限流算法

漏桶限流算法的基本思路是，设定一个固定容量的漏桶，请求先经过漏桶，然后按照漏桶的速率流出，如果请求超出了漏桶的容量，就进行限流处理。

漏桶限流算法的实现步骤：

1. 记录该算法的容量和速率
2. 当一个请求到达时，将其加入漏桶内
3. 漏桶内的请求按照速率流出
4. 如果漏桶已满，且仍有请求到达，就进行限流处理

下面是一个Java实现漏桶限流算法的示例：

public class LeakyBucketLimiter {
    private final int capacity;
    private final int rate;
    private int water;
    private long lastLeakyTime;

    public LeakyBucketLimiter(int capacity, int rate) {
        this.capacity = capacity;
        this.rate = rate;
        this.water = 0;
        this.lastLeakyTime = System.currentTimeMillis();
    }

    public synchronized boolean tryAcquire() {
        long now = System.currentTimeMillis();
        water = Math.max(0, water - (int) ((now - lastLeakyTime) * rate / 1000));
        lastLeakyTime = now;
        if (water + 1 <= capacity) {
            water++;
            return true;
        } else {
            return false;
        }
    }
}

示例说明

以上是两种主流的限流算法，它们的实现方式各有不同，可以在不同的场景下进行使用。

例如，在一个Web应用中，如果希望限定某个接口在10秒钟内只能接受1000个请求，就可以使用固定时间窗口限流算法进行限流。

public class MyController {
    private final FixedWindowLimiter limiter = new FixedWindowLimiter(1000, 10000);

    @GetMapping("/myApi")
    public String myApi() {
        if (!limiter.tryAcquire()) {
            throw new RuntimeException("请求被限流了");
        }
        // 正常处理逻辑
        return "Success";
    }
}

又如，在一个消息队列系统中，希望限制每秒钟处理10个消息，就可以使用漏桶限流算法进行限流。

public class MyConsumer {
    private final LeakyBucketLimiter limiter = new LeakyBucketLimiter(100, 10);

    public void handleMessage(Message message) {
        if (!limiter.tryAcquire()) {
            // 处理速度太慢，请求被限流了
            return;
        }
        // 处理消息
        System.out.println(message);
    }
}

在实际场景中，可以根据业务情况选择适合的限流算法。