Java常见的限流算法

1、限流算法简介

在分布式系统中，高并发场景下，为了防止系统因突然的流量激增而导致的崩溃，同时保证服务的高可用性和稳定性，限流是最常用的手段。常见的限流算法主要有：固定窗口算法、滑动窗口算法、漏桶算法、令牌桶算法。

2、固定窗口算法

固定窗口限流算法，也叫计数器限流算法，是最简单的一种限流算法。主要原理是：通过设定一个固定大小的时间窗口，在该时间窗口内允许通过的请求数量。每个请求进来都会在计数器上加一，当计数器达到设定的阈值时，请求会被拒绝。当超过设置的时间，计数器会重置为0。

import java.util.concurrent.atomic.AtomicInteger;

public class FixedWindowRateLimiter {
    private final int maxRequests; // 每个窗口的最大请求数
    private final long windowSizeInMillis; // 窗口大小（毫秒）
    private long windowStart; // 当前窗口的开始时间
    private AtomicInteger requestCount; // 当前窗口的请求计数

    public FixedWindowRateLimiter(int maxRequests, long windowSizeInMillis) {
        this.maxRequests = maxRequests;
        this.windowSizeInMillis = windowSizeInMillis;
        this.windowStart = System.currentTimeMillis();
        this.requestCount = new AtomicInteger(0);
    }

    public synchronized boolean allowRequest() {
        long now = System.currentTimeMillis();
        if (now - windowStart >= windowSizeInMillis) {
            // 如果当前时间超过了窗口的结束时间，重置窗口
            windowStart = now;
            requestCount.set(0);
        }

        if (requestCount.incrementAndGet() <= maxRequests) {
            // 如果请求数未超过限制，允许请求
            return true;
        } else {
            // 否则，拒绝请求
            return false;
        }
    }

    public static void main(String[] args) {
        // 创建一个限流器，每秒最多允许10个请求
        FixedWindowRateLimiter rateLimiter = new FixedWindowRateLimiter(10, 1000);

        // 模拟请求
        for (int i = 0; i < 20; i++) {
            if (rateLimiter.allowRequest()) {
                System.out.println("Request " + i + " is allowed.");
            } else {
                System.out.println("Request " + i + " is denied.");
            }

            // 模拟请求间隔
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

优点：

• 实现简单，容易理解。
• 适用于突发流量较小的场景。

缺点：

• 无法处理时间窗口的临界突变问题。
• 对于高并发场景，难以保证系统稳定性。
• 无法实现更加精细的限流控制。

3、滑动窗口算法

滑动窗口算法相当于对固定窗口算法的一种改进。在滑动窗口算法中，主要是通过维护一个固定大小的时间窗口，并随着时间的推移向前滑动来计算窗口内的请求总数。这样可以在不牺牲实时性的情况下，平滑地处理流量变化。

import java.util.LinkedList;
import java.util.Queue;

public class SlidingWindowRateLimiter {
    private final int maxRequests;
    private final long windowSizeInMillis;
    private final Queue<Long> requestTimestamps;

	/**
	 * maxRequests  在时间窗口内允许的最大请求数
	 * windowSizeInMillis 时间窗口的大小，以毫秒为单位
	 */
    public SlidingWindowRateLimiter(int maxRequests, long windowSizeInMillis) {
        this.maxRequests = maxRequests;
        this.windowSizeInMillis = windowSizeInMillis;
        this.requestTimestamps = new LinkedList<>();
    }

	/**
	 * 判断当前请求是否被允许。
	 * 
	 * 首先移除掉已经超出时间窗口的请求，然后检查当前窗口内的请求数量是否小于最大请求数。
	 */
    public synchronized boolean allowRequest() {
        long currentTime = System.currentTimeMillis();
        long windowStart = currentTime - windowSizeInMillis;

        // 移除窗口之外的请求时间戳
        while (!requestTimestamps.isEmpty() && requestTimestamps.peek() < windowStart) {
            requestTimestamps.poll();
        }

        if (requestTimestamps.size() < maxRequests) {
            requestTimestamps.add(currentTime);
            return true;
        } else {
            return false;
        }
    }

    public static void main(String[] args) {
        // 创建一个限流器，允许每秒最多10个请求
        SlidingWindowRateLimiter rateLimiter = new SlidingWindowRateLimiter(10, 1000);

        // 模拟请求
        for (int i = 0; i < 20; i++) {
            if (rateLimiter.allowRequest()) {
                System.out.println("Request " + i + " is allowed.");
            } else {
                System.out.println("Request " + i + " is denied.");
            }

            // 模拟请求间隔
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

优点：

• 精确性：滑动窗口算法能够更精确地控制请求流量，因为它会在时间窗口内不断滑动，实时更新请求计数。
• 稳定性：解决了固定窗口算法的窗口边界问题，避免突发流量压垮服务器。

缺点：

• 性能：在高并发场景下，使用 synchronized 可能会成为瓶颈，可以考虑使用更高效的并发数据结构或算法优化。
• 内存消耗：需要存储每个请求的时间戳，可能会导致内存消耗较大。

4、漏桶算法

漏桶算法是一种基于固定速率的流量控制算法。在漏桶算法中，请求像水一样不断地注入漏桶，而漏桶会按照固定的速率将水漏掉。如果注入的速率持续大于漏出的速率，则会出现限流的效果。漏桶算法可以限制请求的速率，并且可以防止出现过载的情况。如果入口流量过大，漏桶可能会溢出，导致数据丢失。

import java.util.concurrent.TimeUnit;

public class LeakyBucket {
    private final int capacity; // 漏桶的容量
    private final int rate; // 漏桶的出水速率（单位时间内允许通过的请求数）
    private int water; // 当前桶中的水量（请求数）
    private long lastTime; // 上次漏水的时间

    public LeakyBucket(int capacity, int rate) {
        this.capacity = capacity;
        this.rate = rate;
        this.water = 0;
        this.lastTime = System.nanoTime();
    }
	
	/**
	 * 判断当前请求是否可以通过
	 * 
	 * 通过计算自上次漏水以来的时间间隔，并根据速率计算出应漏掉的水量
	 * 更新桶中的水量，并将 lastTime 更新为当前时间
	 * 如果桶未满，则允许请求通过，并增加桶中的水量；否则，拒绝请求
	 */
    public synchronized boolean grantAccess() {
        long now = System.nanoTime();
        long elapsed = now - lastTime;
        // 计算漏掉的水量
        int leaked = (int) (elapsed * rate / TimeUnit.SECONDS.toNanos(1));
        if (leaked > 0) {
            water = Math.max(0, water - leaked);
            lastTime = now;
        }

        if (water < capacity) {
            water++;
            return true;
        } else {
            return false;
        }
    }

    public static void main(String[] args) {
        LeakyBucket bucket = new LeakyBucket(10, 1); // 容量为10，速率为1个请求/秒

        // 模拟请求
        for (int i = 0; i < 20; i++) {
            if (bucket.grantAccess()) {
                System.out.println("Request " + i + " is allowed.");
            } else {
                System.out.println("Request " + i + " is denied.");
            }

            try {
                Thread.sleep(100); // 每100毫秒发一个请求
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

优点：

• 可以限制请求的速率，并且不会出现过载的情况。
• 可以实现较为精细的限流控制。

缺点：

• 如果入口流量过大，超过了桶的容量，那么就需要丢弃部分请求。
• 由于速率是固定的，即使下游能够处理更大的流量，漏桶也不允许突发流量通过。

5、令牌桶算法

令牌桶算法是一种基于令牌的流量控制算法。在令牌桶算法中，主要是通过生成令牌来控制请求的处理速度，系统会向令牌桶中不断添加令牌，每个请求会消耗掉一个令牌，如果令牌桶中没有足够的令牌，则请求会被拒绝。令牌桶算法可以限制请求的速率，同时不会出现过载的情况。

令牌桶算法原理

1. 令牌生成：系统以恒定的速率向桶中添加令牌。桶的容量是有限的，当桶满时，多余的令牌会被丢弃。
2. 请求处理：每个请求需要从桶中获取一个令牌才能被处理。如果桶中没有令牌，请求会被拒绝或延迟。
3. 速率控制：通过控制令牌的生成速率和桶的容量，可以控制请求的处理速率。

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

/**
* 定义了令牌桶的容量和令牌生成速率
*/
public class TokenBucket {
    private final int capacity; // 桶的容量
    private final int tokensPerSecond; // 每秒生成的令牌数
    private AtomicInteger tokens; // 当前令牌数
    private ScheduledExecutorService scheduler;

    public TokenBucket(int capacity, int tokensPerSecond) {
        this.capacity = capacity;
        this.tokensPerSecond = tokensPerSecond;
        this.tokens = new AtomicInteger(0);
        this.scheduler = Executors.newScheduledThreadPool(1);
        startTokenProducer();
    }
    
    /**
	 * 开始生成令牌
	 * 
	 * 使用ScheduledExecutorService定期向桶中添加令牌
	 */
    private void startTokenProducer() {
        scheduler.scheduleAtFixedRate(() -> {
            if (tokens.get() < capacity) {
                tokens.incrementAndGet();
            }
        }, 0, 1000 / tokensPerSecond, TimeUnit.MILLISECONDS);
    }
    
    /**
	 * 尝试从桶中获取令牌
	 * 
	 * 如果成功则返回true，否则返回false
	 */
    public boolean tryConsume() {
        if (tokens.get() > 0) {
            tokens.decrementAndGet();
            return true;
        }
        return false;
    }

    // 关闭调度器
    public void shutdown() {
        scheduler.shutdown();
    }

    public static void main(String[] args) {
        TokenBucket tokenBucket = new TokenBucket(10, 5); // 容量为10，每秒生成5个令牌

        // 模拟请求
        for (int i = 0; i < 20; i++) {
            if (tokenBucket.tryConsume()) {
                System.out.println("Request " + i + " processed.");
            } else {
                System.out.println("Request " + i + " rejected.");
            }

            try {
                Thread.sleep(200); // 每200ms发起一个请求
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        tokenBucket.shutdown();
    }
}

优点：

• 令牌桶算法可以处理突发流量。当桶满时，能够以最大速度处理请求。
• 与漏桶算法相比，令牌桶算法提供了更大的灵活性。

缺点：

• 需要维护令牌桶和令牌生成速度等状态信息，实现较为复杂。
• 当令牌桶溢出时，会导致请求被拒绝，影响用户体验。