详解5种Java中常见限流算法

在高并发场景下，为了保证系统的稳定性与安全性，通常需要对流量进行限制与控制。而限流算法就是实现这种控制的重要手段之一。在Java开发中，有多种常见的限流算法可供选择，本文将对这些算法进行详细讲解。

令牌桶算法

令牌桶算法是一种基于令牌（Token）实现的限流算法。在该算法中，系统会定期向桶中添加一定数量的令牌，每当有请求到来时，系统会去桶中获取对应数量的令牌进行处理，若桶中没有足够数量的令牌则该请求将被阻塞或者拒绝。该算法的优点在于可以预估待处理请求的数量，并且可以应对突发流量。

代码示例：

public class TokenBucket {

    private int capacity;
    private int rate;
    private int tokens;
    private long timestamp;

    public TokenBucket(int capacity, int rate) {
        this.capacity = capacity;
        this.rate = rate;
        this.tokens = capacity;
        this.timestamp = System.currentTimeMillis();
    }

    public synchronized boolean consume(int num) {
        refill();
        if (tokens < num) {
            return false;
        } else {
            tokens -= num;
            return true;
        }
    }

    private void refill() {
        long now = System.currentTimeMillis();
        long duration = Math.max(now - timestamp, 0);
        int units = (int) (duration * rate / 1000);
        tokens = Math.min(tokens + units, capacity);
        timestamp = now;
    }

}

漏桶算法

漏桶算法是一种基于桶的实现的限流算法。在该算法中，系统会将请求放入到漏桶中，然后以固定的速率进行处理，若漏桶已满，则多余的请求会被直接拒绝。该算法的优点在于可以最大程度地平滑请求的处理速率，避免系统崩溃。

代码示例：

public class LeakyBucket {

    private int capacity;
    private int rate;
    private int water;
    private long timestamp;

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

    public synchronized boolean consume(int num) {
        refill();
        if (water < num) {
            return false;
        } else {
            water -= num;
            return true;
        }
    }

    private void refill() {
        long now = System.currentTimeMillis();
        long duration = Math.max(now - timestamp, 0);
        int units = (int) (duration * rate / 1000);
        water = Math.max(0, water - (capacity - units));
        timestamp = now;
    }

}

计数器限流

计数器限流是一种简单粗暴的限流算法，就是在系统处理请求的时候对请求的次数进行计数，当达到设定的阈值时，就拒绝后续的请求。该算法的优点在于实现简单，但同时也会存在一些缺点，例如无法应对突发流量。

代码示例：

public class Counter {

    private int count;
    private int threshold;

    public Counter(int threshold) {
        this.count = 0;
        this.threshold = threshold;
    }

    public synchronized boolean consume() {
        if (count >= threshold) {
            return false;
        } else {
            count++;
            return true;
        }
    }

}

滑动窗口限流

滑动窗口限流是一种基于时间窗口的限流算法。在该算法中，系统会对一段时间内的请求进行统计，并根据统计结果进行限流处理。该算法的优点在于可以应对突发流量，且相对比较平滑。

代码示例：

public class SlidingWindow {

    private int capacity;
    private int rate;
    private int[] count;
    private long[] timestamp;

    public SlidingWindow(int capacity, int rate) {
        this.capacity = capacity;
        this.rate = rate;
        this.count = new int[capacity];
        this.timestamp = new long[capacity];
        Arrays.fill(timestamp, System.currentTimeMillis());
    }

    public synchronized boolean consume() {
        refill();
        int sum = 0;
        for (int i = 0; i < count.length; i++) {
            sum += count[i];
        }
        if (sum >= rate) {
            return false;
        } else {
            count[count.length - 1]++;
            return true;
        }
    }

    private void refill() {
        long now = System.currentTimeMillis();
        long duration = now - timestamp[0];
        int units = (int) (duration * rate / 1000);
        for (int i = 0; i < units; i++) {
            System.arraycopy(count, 1, count, 0, count.length - 1);
            count[count.length - 1] = 0;
            timestamp[i] = now;
        }
    }

}

漏斗算法

漏斗算法是一种比较特殊的限流算法，常用于对请求的处理能力进行限制。在该算法中，系统会通过不同的漏斗大小来区分对请求的处理能力，并根据不同的漏斗大小来控制请求的处理速度。该算法的优点在于可以有效地处理突发流量，并在处理压力较大时能够保持系统的相对稳定性。

代码示例：

public class Funnel {

    private int capacity;
    private float rate;
    private float volume;
    private long timestamp;

    public Funnel(int capacity, float rate) {
        this.capacity = capacity;
        this.rate = rate;
        this.volume = capacity;
        this.timestamp = System.currentTimeMillis();
    }

    public synchronized boolean consume(int num) {
        refill();
        if (volume >= num) {
            volume -= num;
            return true;
        } else {
            return false;
        }
    }

    private void refill() {
        long now = System.currentTimeMillis();
        long duration = Math.max(now - timestamp, 0);
        float units = (float) duration * rate / 1000;
        if (units > 0) {
            volume = Math.min(volume + units, capacity);
            timestamp = now;
        }
    }

}

以上就是五种常见的Java限流算法的详细讲解。在实际应用中，我们可以根据需求选择合适的算法来进行限流处理。