引言：当系统遇上流量暴击

面试官："假设你现在负责双十一秒杀系统，突然涌入百万请求，你怎么保护系统不挂？"

我："这个简单，先关机保平安！"

面试官："......你明天不用来上班了。"

开个玩笑！真实场景中我们需要的是限流这个神器。今天我们就用Java代码来深入探讨限流组件的奥秘！

一、四大限流算法Java实现

1.1 计数器算法：简单粗暴版

public class CounterLimiter {
    private long windowStart;
    private int count;
    private final int limit;
    private final long windowSizeInMillis;

    public CounterLimiter(int limit, long windowSizeInMillis) {
        this.limit = limit;
        this.windowSizeInMillis = windowSizeInMillis;
        this.windowStart = System.currentTimeMillis();
        this.count = 0;
    }

    public synchronized boolean tryAcquire() {
        long now = System.currentTimeMillis();
        if (now - windowStart > windowSizeInMillis) {
            windowStart = now;
            count = 0;
        }
        if (count < limit) {
            count++;
            return true;
        }
        return false;
    }

    public static void main(String[] args) throws InterruptedException {
        CounterLimiter limiter = new CounterLimiter(5, 1000); // 每秒5次
        
        for (int i = 0; i < 10; i++) {
            System.out.println("Request " + i + ": " + (limiter.tryAcquire() ? "OK" : "限流"));
            Thread.sleep(200);
        }
    }
}

问题：窗口边界突刺

问题场景：

在时间窗口的最后一毫秒收到100个请求
下一个窗口的第一毫秒又收到100个请求
实际在2毫秒内处理了200个请求，超出系统承受能力

1.2 滑动窗口算法：升级版

public class SlidingWindowLimiter {
    private final int[] timeSlices;
    private final int windowSize;
    private final int limit;
    private long lastTime;
    private int index;

    public SlidingWindowLimiter(int windowSize, int limit) {
        this.windowSize = windowSize;
        this.limit = limit;
        this.timeSlices = new int[windowSize];
        this.lastTime = System.currentTimeMillis();
    }

    public synchronized boolean tryAcquire() {
        long now = System.currentTimeMillis();
        long elapsed = now - lastTime;
        
        // 计算过期的格子数
        int expired = (int) (elapsed / 1000);
        if (expired > 0) {
            // 滑动窗口
            for (int i = 1; i <= expired; i++) {
                timeSlices[(index + i) % windowSize] = 0;
            }
            index = (index + expired) % windowSize;
            lastTime = now;
        }
        
        int total = 0;
        for (int count : timeSlices) {
            total += count;
        }
        
        if (total < limit) {
            timeSlices[index]++;
            return true;
        }
        return false;
    }
}

问题1：内存与计算开销

问题表现：

空间复杂度：O(N)的时间片存储
时间复杂度：每次请求需要遍历整个窗口计算总和
精度与性能矛盾：时间片划分越细，精度越高，但内存消耗越大

问题1：伪滑动问题

实际实现中为了性能，往往采用非精确滑动，导致：

时间片未及时滑动产生误差
多线程环境下的同步开销

1.3 漏桶算法：恒定速率版

public class LeakyBucketLimiter {
    private final long capacity;
    private long remaining;
    private final long leakRate; // 毫秒/个
    private long lastLeakTime;
    private final Object lock = new Object();

    public LeakyBucketLimiter(long capacity, long leakRatePerSecond) {
        this.capacity = capacity;
        this.remaining = capacity;
        this.leakRate = 1000 / leakRatePerSecond; // 每个请求需要的毫秒数
        this.lastLeakTime = System.currentTimeMillis();
    }

    public boolean tryAcquire() {
        synchronized (lock) {
            leak();
            if (remaining > 0) {
                remaining--;
                return true;
            }
            return false;
        }
    }

    private void leak() {
        long now = System.currentTimeMillis();
        long elapsed = now - lastLeakTime;
        long leaks = elapsed / leakRate;
        
        if (leaks > 0) {
            remaining = Math.min(capacity, remaining + leaks);
            lastLeakTime = now;
        }
    }
}

问题1：无法应对突发流量

典型缺陷：

突发流量饥饿：即使系统有空闲资源，也无法立即利用
固定速率不灵活：无法适应系统处理能力的动态变化
实现复杂度：需要维护独立的漏水线程或时间计算

问题2：参数配置难题

漏出速率设置过低：系统资源利用率不足
漏出速率设置过高：失去保护意义
桶容量设置：太大导致内存浪费，太小容易限流过度

1.4 令牌桶算法：灵活突发版

public class TokenBucketLimiter {
    private final double capacity;
    private double tokens;
    private long lastRefillTime;
    private final double refillRate; // 令牌/毫秒
    private final Object lock = new Object();

    public TokenBucketLimiter(double capacity, double refillRatePerSecond) {
        this.capacity = capacity;
        this.tokens = capacity;
        this.refillRate = refillRatePerSecond / 1000;
        this.lastRefillTime = System.currentTimeMillis();
    }

    public boolean tryAcquire(int numTokens) {
        synchronized (lock) {
            refill();
            if (tokens >= numTokens) {
                tokens -= numTokens;
                return true;
            }
            return false;
        }
    }

    private void refill() {
        long now = System.currentTimeMillis();
        double elapsed = now - lastRefillTime;
        double newTokens = elapsed * refillRate;
        
        if (newTokens > 0) {
            tokens = Math.min(capacity, tokens + newTokens);
            lastRefillTime = now;
        }
    }
}

问题1：突发流量可能压垮下游

潜在风险：

令牌囤积问题：

系统空闲时积累大量令牌，突发流量时集中释放

可能导致数据库连接池被打满

可能引发缓存雪崩

时间同步问题：

分布式环境下各节点时间不同步

导致限流不准确

精度问题：

基于时间的令牌添加存在精度误差

问题1：实现复杂度

需要精确的时间计算
多线程竞争下的性能问题
预热模型的实现复杂度高

二、生产级限流组件Java实战

2.1 Guava RateLimiter实战

import com.google.common.util.concurrent.RateLimiter;

public class OrderService {
    private final RateLimiter rateLimiter;
    
    public OrderService() {
        // 每秒处理2个订单，预热期3秒
        this.rateLimiter = RateLimiter.create(2.0, 3, TimeUnit.SECONDS);
    }
    
    public void processOrder(Order order) {
        // 尝试获取令牌，非阻塞
        if (rateLimiter.tryAcquire()) {
            // 实际订单处理逻辑
            System.out.println("处理订单: " + order.getId());
        } else {
            // 触发降级逻辑
            System.out.println("系统繁忙，请稍后重试");
            throw new RateLimitException("系统繁忙");
        }
    }
    
    static class RateLimitException extends RuntimeException {
        public RateLimitException(String message) {
            super(message);
        }
    }
}

2.2 Redis + Lua分布式限流

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

public class RedisRateLimiter {
    private final JedisPool jedisPool;
    private final String script = 
        "local key = KEYS[1]\n" +
        "local limit = tonumber(ARGV[1])\n" +
        "local window = tonumber(ARGV[2])\n" +
        "local current = redis.call('GET', key)\n" +
        "if current and tonumber(current) >= limit then\n" +
        "    return 0\n" +
        "else\n" +
        "    redis.call('INCR', key)\n" +
        "    if current == nil then\n" +
        "        redis.call('EXPIRE', key, window)\n" +
        "    end\n" +
        "    return 1\n" +
        "end";

    public RedisRateLimiter(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
    }

    public boolean allowRequest(String key, int limit, int windowInSeconds) {
        try (Jedis jedis = jedisPool.getResource()) {
            Object result = jedis.eval(script, 1, key, 
                String.valueOf(limit), 
                String.valueOf(windowInSeconds));
            return "1".equals(result.toString());
        }
    }
}

2.3 Spring Cloud Gateway限流

@Configuration
public class RateLimitConfig {
    
    @Bean
    public RedisRateLimiter redisRateLimiter() {
        return new RedisRateLimiter(10, 20); // 每秒10个，突发20个
    }
    
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
            .route("order-service", r -> r.path("/orders/**")
                .filters(f -> f.requestRateLimiter(c -> {
                    c.setRateLimiter(redisRateLimiter());
                    c.setKeyResolver(exchange -> 
                        Mono.just(exchange.getRequest().getRemoteAddress().getAddress().getHostAddress()));
                }))
            .build();
    }
}

三、高级应用场景Java实现

3.1 热点参数限流

public class HotParamLimiter {
    private final LoadingCache limiters;
    
    public HotParamLimiter(double permitsPerSecond) {
        this.limiters = CacheBuilder.newBuilder()
            .maximumSize(1000)
            .expireAfterAccess(1, TimeUnit.HOURS)
            .build(new CacheLoader() {
                @Override
                public RateLimiter load(String key) {
                    return RateLimiter.create(permitsPerSecond);
                }
            });
    }
    
    public boolean tryAccess(String paramKey) {
        RateLimiter limiter = limiters.getUnchecked(paramKey);
        return limiter.tryAcquire();
    }
}

// 使用示例：商品ID限流
HotParamLimiter productLimiter = new HotParamLimiter(5.0); // 每个商品ID每秒5次
if (productLimiter.tryAccess(productId)) {
    // 处理请求
} else {
    // 限流处理
}

3.2 自适应限流

public class AdaptiveLimiter {
    private volatile double currentLimit = 10.0; // 初始限流值
    private final double minLimit = 1.0;
    private final double maxLimit = 100.0;
    private final ScheduledExecutorService executor = 
        Executors.newSingleThreadScheduledExecutor();
    
    public AdaptiveLimiter() {
        // 每10秒调整一次限流值
        executor.scheduleAtFixedRate(this::adjustLimit, 10, 10, TimeUnit.SECONDS);
    }
    
    public boolean tryAcquire() {
        // 简单计数器实现
        // 实际中可以使用更精确的算法
        if (currentCounter < currentlimit currentcounter return true return false private void adjustlimit cpu double cpuusage='getCpuUsage();' double memoryusage='getMemoryUsage();' if cpuusage> 0.8 || memoryUsage > 0.8) {
            currentLimit = Math.max(minLimit, currentLimit * 0.9); // 降级
        } else if (cpuUsage < 0.5 && memoryUsage < 0.5) {
            currentLimit = Math.min(maxLimit, currentLimit * 1.1); // 扩容
        }
        
        currentCounter = 0; // 重置计数器
    }
    
    // 省略获取系统指标的方法...
}

四、面试实战：限流算法对比

面试官："你能比较下这几种限流算法的适用场景吗？"

我："当然！请看我的Java实现对比表："

算法	Java实现复杂度	适用场景	优点	缺点
计数器		简单场景	实现简单	窗口切换突刺
滑动窗口		精确控制	平滑限流	实现稍复杂
漏桶		恒定速率	输出稳定	不允许突发
令牌桶		灵活突发	允许突发	实现较复杂

面试官："如果让你设计一个电商秒杀系统，你会怎么组合使用这些限流？"

我："我会这样设计（Java伪代码）："

public class SeckillSystem {
    // 多级限流
    private final RateLimiter globalLimiter = RateLimiter.create(10000); // 全局限流
    private final HotParamLimiter itemLimiter = new HotParamLimiter(100); // 商品维度
    private final Map userLimiters = new ConcurrentHashMap<>(); // 用户维度
    
    public SeckillResult seckill(long userId, long itemId) {
        // 1. 全局限流
        if (!globalLimiter.tryAcquire()) {
            return SeckillResult.fail("活动太火爆，请稍后重试");
        }
        
        // 2. 商品维度限流
        if (!itemLimiter.tryAccess(String.valueOf(itemId))) {
            return SeckillResult.fail("当前商品抢购人数过多");
        }
        
        // 3. 用户维度限流
        RateLimiter userLimiter = userLimiters.computeIfAbsent(userId, 
            id -> RateLimiter.create(5)); // 每个用户最多5次/秒
        if (!userLimiter.tryAcquire()) {
            return SeckillResult.fail("您操作太频繁啦");
        }
        
        // 实际秒杀逻辑...
        return doSeckill(userId, itemId);
    }
}

五、性能优化技巧

5.1 高性能计数器

public class HighPerformanceCounter {
    private final AtomicLong[] counters;
    private final int slotCount;
    private final long intervalInMillis;
    private volatile int currentSlot;
    
    public HighPerformanceCounter(int slotCount, long intervalInMillis) {
        this.slotCount = slotCount;
        this.intervalInMillis = intervalInMillis;
        this.counters = new AtomicLong[slotCount];
        for (int i = 0; i < slotcount i countersi='new' atomiclong0 this.currentslot='0;' startrotate private void startrotate scheduledexecutorservice executor='Executors.newSingleThreadScheduledExecutor();' executor.scheduleatfixedrate -> {
            int nextSlot = (currentSlot + 1) % slotCount;
            counters[nextSlot].set(0);
            currentSlot = nextSlot;
        }, intervalInMillis, intervalInMillis, TimeUnit.MILLISECONDS);
    }
    
    public void increment() {
        counters[currentSlot].incrementAndGet();
    }
    
    public long getCount() {
        long sum = 0;
        for (AtomicLong counter : counters) {
            sum += counter.get();
        }
        return sum;
    }
}

5.2 无锁令牌桶

public class LockFreeTokenBucket {
    private final AtomicLong lastRefillTime;
    private final AtomicDouble tokens;
    private final double capacity;
    private final double refillRatePerMillis;
    
    public LockFreeTokenBucket(double capacity, double refillRatePerSecond) {
        this.capacity = capacity;
        this.refillRatePerMillis = refillRatePerSecond / 1000;
        this.lastRefillTime = new AtomicLong(System.currentTimeMillis());
        this.tokens = new AtomicDouble(capacity);
    }
    
    public boolean tryAcquire(double numTokens) {
        while (true) {
            long now = System.currentTimeMillis();
            long lastTime = lastRefillTime.get();
            double elapsed = now - lastTime;
            
            double newTokens = elapsed * refillRatePerMillis;
            double currentTokens = Math.min(capacity, tokens.get() + newTokens);
            
            if (currentTokens < numTokens) {
                return false;
            }
            
            if (lastRefillTime.compareAndSet(lastTime, now)) {
                if (tokens.compareAndSet(currentTokens, currentTokens - numTokens)) {
                    return true;
                }
            }
        }
    }
    
    static class AtomicDouble {
        private final AtomicLong bits;
        
        public AtomicDouble(double value) {
            this.bits = new AtomicLong(Double.doubleToLongBits(value));
        }
        
        public double get() {
            return Double.longBitsToDouble(bits.get());
        }
        
        public boolean compareAndSet(double expect, double update) {
            return bits.compareAndSet(Double.doubleToLongBits(expect),
                                  Double.doubleToLongBits(update));
        }
    }
}

六、生产级限流组件实战

6.1 Guava RateLimiter

面试官："说说实际项目中常用的限流工具？"

我："Guava的RateLimiter啊！用起来比泡面还简单——加水（配置）就能用！"

示例代码：

// 创建一个每秒2个令牌的限流器
RateLimiter limiter = RateLimiter.create(2.0); 

void submitOrder() {
    if (limiter.tryAcquire()) {  // 非阻塞获取
        // 处理订单
    } else {
        // 返回"系统繁忙"提示
    }
}

黑科技：Guava采用了令牌桶+预热机制，避免冷启动时直接打满系统：

// 预热型限流器：每秒5个请求，预热时间3秒
RateLimiter.create(5, 3, TimeUnit.SECONDS);

6.2 Redis + Lua分布式限流

面试官："分布式系统怎么实现全局限流？"

我："Redis+Lua脚本，原子操作一把梭！就像银行总行控制所有ATM的取现总额！"

原理：利用Redis的原子性和Lua脚本实现集群限流

示例：

-- KEYS[1]: 限流key
-- ARGV[1]: 时间窗口(秒)
-- ARGV[2]: 限制次数
local key = KEYS[1]
local limit = tonumber(ARGV[2])
local window = tonumber(ARGV[1])

local current = redis.call('GET', key)
if current and tonumber(current) >= limit then
    return 0
else
    redis.call('INCR', key)
    if current == nil then
        redis.call('EXPIRE', key, window)
    end
    return 1
end

6.3 Sentinel全局限流

面试官："微服务架构怎么玩限流？"

我："阿里Sentinel安排上！配上控制台还能玩出花来！"

配置示例：

// 定义资源
@SentinelResource(value = "orderQuery", blockHandler = "handleBlock")
public List queryOrders() {
    // 业务逻辑
}

// 限流处理
public List handleBlock(BlockException ex) {
    return Collections.emptyList(); 
}

Sentinel高级功能：

基于QPS/线程数的限流
熔断降级
系统自适应保护
热点参数限流

七、限流策略进阶思考

7.1 限流维度设计

面试官："除了全局限流，还能从哪些维度设计？"

我："看我七十二变！"

维度	示例	适用场景
IP限流	每个IP每秒10次	防爬虫
用户限流	每个用户每分钟5单	防刷单
接口限流	支付接口每秒100次	核心接口保护
参数限流	同一商品ID每秒5次查询	防热点穿透

7.2 限流后的优雅处理

面试官："被限流的请求怎么处理？直接返回404？"

我："格局打开！我们可以..."

队列等待：像迪士尼乐园，发"快速通行证"排队
降级返回：返回缓存数据或静态页面
分层处理：VIP用户走特殊通道
友好提示："当前排队人数较多，您预计需要等待2分钟"

7.3 限流数值怎么定？

面试官："你说限流100QPS，这个100是怎么来的？"

我："三步走战略："

压测摸底：用JMeter测出系统最大承受能力
黄金比例：通常取压测峰值的70%作为阈值
动态调整：根据监控指标实时调整

八、限流与其他架构模式的联合作战

8.1 限流 vs 熔断

面试官："限流和熔断有什么区别？"

我："限流是预防针，熔断是急诊室！"

限流：健康时预防过载
熔断：生病时快速失败

8.2 限流 vs 降级

面试官："那降级呢？"

我："降级就像战时配给制，优先保障核心功能！"

联合作战方案：

请求进入 -> 限流 -> 系统负载高 -> 熔断 -> 降级

8.3 限流与弹性伸缩

面试官："有了K8s自动扩缩容还需要限流吗？"

我："需要！就像再有钱的土豪也不会无限度消费！"

原因：

扩容需要时间（通常分钟级）
有些瓶颈无法通过扩容解决（如数据库）
控制成本考虑

九、真实案例：电商大促限流方案

9.1 秒杀系统三级限流

前端限流：

按钮置灰

随机排队进度条

网关层限流：

Nginx限流模块

limit_req_zone $binary_remote_addr zone=perip:10m rate=10r/s; location /seckill { limit_req zone=perip burst=20 nodelay; }

3、服务层限流：

Sentinel集群流控

9.2 热点数据访问方案

// 使用Guava Cache实现本地缓存+限流
LoadingCache counter = CacheBuilder.newBuilder()
    .expireAfterWrite(1, TimeUnit.SECONDS)
    .build(new CacheLoader() {
        @Override
        public AtomicLong load(String key) {
            return new AtomicLong(0);
        }
    });

public boolean canAccess(String key) {
    try {
        return counter.get(key).incrementAndGet() <= 50; // 每秒50次
    } catch (ExecutionException e) {
        return false;
    }
}

十、面试加餐：高频考点解析

面试官："如果让你设计一个分布式限流系统，你会考虑哪些点？"

我："这题我会！请听我的架构三连："

准确性：
时钟同步问题（NTP服务）
Redis原子操作（Lua脚本）
性能：
本地缓存+定期同步
分片计数减少竞争
容错：
降级策略（如故障时放开限流）
多级降级（先严格后宽松）

架构图：

Client -> 本地限流器 -> Redis集群限流 -> 降级处理
           ↑定期同步       ↑故障检测

结语：限流艺术的哲学思考

最后，让我们升华一下主题——限流不仅是技术，更是一种系统设计的哲学：

取舍之道：在可用性和一致性间找到平衡
防御性设计：永远为最坏情况做准备
弹性思维：系统要像弹簧，能屈能伸

算法选择

选择合适的算法：根据业务特点选择最适合的限流算法
多级限流：从网关到服务到方法，层层防护
监控告警：实时监控限流情况，及时调整策略
优雅降级：被限流的请求要给用户友好提示
性能考量：高并发场景下注意锁竞争问题

记住：没有限流的系统就像没有刹车的跑车，跑得越快，死得越惨！

Java程序员限流指南:从算法原理到面试实战

引言：当系统遇上流量暴击

一、四大限流算法Java实现

1.1 计数器算法：简单粗暴版

1.2 滑动窗口算法：升级版

1.3 漏桶算法：恒定速率版

1.4 令牌桶算法：灵活突发版

二、生产级限流组件Java实战

2.1 Guava RateLimiter实战

2.2 Redis + Lua分布式限流

2.3 Spring Cloud Gateway限流

三、高级应用场景Java实现

3.1 热点参数限流

3.2 自适应限流

四、面试实战：限流算法对比

五、性能优化技巧

5.1 高性能计数器

5.2 无锁令牌桶

六、生产级限流组件实战

6.1 Guava RateLimiter

6.2 Redis + Lua分布式限流

6.3 Sentinel全局限流

七、限流策略进阶思考

7.1 限流维度设计

7.2 限流后的优雅处理

7.3 限流数值怎么定？

八、限流与其他架构模式的联合作战

8.1 限流 vs 熔断

8.2 限流 vs 降级

8.3 限流与弹性伸缩

九、真实案例：电商大促限流方案

9.1 秒杀系统三级限流

9.2 热点数据访问方案

十、面试加餐：高频考点解析

结语：限流艺术的哲学思考

相关推荐

取消回复欢迎 你 发表评论:

前端面试:iframe 的优缺点? iframe有那些缺点

带斜线的表头制作好了，如何填充内容?这几种方法你更喜欢哪个?

漫学笔记之PHP.ini常用的配置信息

其实模版网站在开发工作中很重要，推荐几个参考站给大家

推荐7个模板代码和其他游戏源码下载的网址

[干货] JAVA - JVM - 2 内存两分 [干货]+java+-+jvm+-+2+内存两分吗

正在学习使用python搭建自动化测试框架?这个系统包你可能会用到

织梦(Dedecms)建站教程 织梦建站详细步骤

【开源分享】2024PHP在线客服系统源码(搭建教程+终身使用)

2024PHP在线客服系统源码+完全开源 带详细搭建教程

取消回复欢迎你发表评论:

织梦(Dedecms)建站教程织梦建站详细步骤

2024PHP在线客服系统源码+完全开源带详细搭建教程