生活中随处可见的限流，在Java中又是怎么应用的呢？(Java中如何实现生活中常见的限流策略？)

原创

ithorizon 6个月前 (10-21) 阅读数 38 #后端开发

Java中的限流策略应用

一、引言

在现实生活中，为了维护系统的稳定性和公平性，我们常常会遇到限流的场景。例如，旅游景点为了防止拥挤，会束缚进入的人数；电商平台为了防止秒杀活动中的恶意刷单，会束缚用户的购买次数。在Java程序中，限流同样是一种重要的保护措施，它可以防止系统由于过载而崩溃。本文将介绍几种常见的限流策略及其在Java中的实现方法。

二、常见的限流策略

限流策略核心有以下几种：

计数器限流

滑动窗口限流

令牌桶限流

漏桶限流

三、计数器限流

计数器限流是最易懂的一种限流策略。它的核心思想是：在单位时间内，只允许固定数量的请求通过。

下面是一个易懂的Java实现：


public class CounterLimiter {
    private final int limit;
    private final long interval;
    private long lastTime;
    private int count;
    public CounterLimiter(int limit, long interval) {
        this.limit = limit;
        this.interval = interval;
        this.lastTime = System.currentTimeMillis();
        this.count = 0;
    }
    public synchronized boolean tryAcquire() {
        long currentTime = System.currentTimeMillis();
        long timeDifference = currentTime - lastTime;
        if (timeDifference > interval) {
            lastTime = currentTime;
            count = 0;
        }
        if (count < limit) {
            count++;
            return true;
        }
        return false;
    }
}

四、滑动窗口限流

滑动窗口限流是对计数器限流的一种优化。它将时间划分为一定数量的窗口，每个窗口允许的请求数量可以不同，从而更加灵活。

下面是一个基于Redis的滑动窗口限流实现：


public class SlidingWindowLimiter {
    private final RedisTemplate redisTemplate;
    private final int limit;
    private final long interval;
    public SlidingWindowLimiter(RedisTemplate redisTemplate, int limit, long interval) {
        this.redisTemplate = redisTemplate;
        this.limit = limit;
        this.interval = interval;
    }
    public boolean tryAcquire(String key) {
        long currentTime = System.currentTimeMillis();
        long windowStart = currentTime - interval;
        String redisKey = key + "_limiter";
        // 删除过期的窗口
        redisTemplate.opsForZSet().removeRangeByScore(redisKey, 0, windowStart);
        // 添加当前请求到窗口
        redisTemplate.opsForZSet().add(redisKey, currentTime, currentTime);
        // 获取当前窗口的请求数量
        long count = redisTemplate.opsForZSet().score(redisKey, currentTime);
        // 判断是否超过束缚
        if (count <= limit) {
            return true;
        }
        return false;
    }
}

五、令牌桶限流

令牌桶限流是一种更加灵活的限流策略。它允许在短时间内超过限流的请求通过，但是长期来看仍然保持一个稳定的请求速率。

下面是一个易懂的Java实现：


public class TokenBucketLimiter {
    private final int limit;
    private final long interval;
    private long lastTime;
    private int tokens;
    public TokenBucketLimiter(int limit, long interval) {
        this.limit = limit;
        this.interval = interval;
        this.lastTime = System.currentTimeMillis();
        this.tokens = limit;
    }
    public synchronized boolean tryAcquire() {
        long currentTime = System.currentTimeMillis();
        long timeDifference = currentTime - lastTime;
        lastTime = currentTime;
        tokens += (int) (timeDifference * limit / interval);
        tokens = Math.min(tokens, limit);
        if (tokens > 0) {
            tokens--;
            return true;
        }
        return false;
    }
}

六、漏桶限流

漏桶限流与令牌桶限流类似，但是其工作原理有所不同。漏桶以固定的速率处理请求，如果请求超过了这个速率，它们将会被缓存起来，直到有足够的空余处理。

下面是一个易懂的Java实现：


public class LeakBucketLimiter {
    private final int limit;
    private final long interval;
    private long lastTime;
    public LeakBucketLimiter(int limit, long interval) {
        this.limit = limit;
        this.interval = interval;
        this.lastTime = System.currentTimeMillis();
    }
    public synchronized boolean tryAcquire() {
        long currentTime = System.currentTimeMillis();
        long timeDifference = currentTime - lastTime;
        lastTime = currentTime;
        if (timeDifference < interval) {
            return false;
        }
        return true;
    }
}