常见的几种限流算法代码实现（JAVA）

已于 2022-08-25 17:00:25 修改
阅读量3.7k 收藏 36
点赞数 9
分类专栏： 数据结构 文章标签： java 算法 面试
于 2022-08-25 16:38:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44991304/article/details/126527087
版权

最近在学习Sentinel组件需要了解限流算法相关的知识，正好在微信公众号上看到了一篇不错的文章，在此记录一下以下是原文链接。

年轻人，来手撸几种常见的限流算法！

限流算法接口

public interface RateLimiter {
   /**
    * 判断请求是否能够通过
    * @return 能通过返回true否则false
    */
   boolean tryAcquire();
}

一，固定窗口限流算法

首先维护一个计数器，将单位时间段当做一个窗口，计数器记录这个窗口接收请求的次数。

  • 当次数少于限流阀值，就允许访问，并且计数器+1
  • 当次数大于限流阀值，就拒绝访问。
  • 当前的时间窗口过去之后，计数器清零。

假设单位时间是1秒，限流阀值为3。在单位时间1秒内，每来一个请求,计数器就加1，如果计数器累加的次数超过限流阀值3，后续的请求全部拒绝。等到1s结束后，计数器清0，重新开始计数。如下图：
在这里插入图片描述
国定窗口算法伪代码实现如下：

public class CounterRateLimiter implements RateLimiter {
    // 每秒限制的请求数
    private final long permitsPerSecond;

    // 上一个窗口开始的时间
    private long timestamp = System.currentTimeMillis();

    // 计数器
    private int counter;

    public CounterRateLimiter(long permitsPerSecond) {
        this.permitsPerSecond = permitsPerSecond;
    }

    @Override
    public synchronized boolean tryAcquire() {
        long now = System.currentTimeMillis();
        // 窗口内请求数量小于阈值，更新计数放行，否则拒绝请求
        if (now - timestamp < 1000) {
            if (counter < permitsPerSecond) {
                counter++;
                return true;
            } else {
                return false;
            }
        }
        // 时间窗口过期，重置计数器和时间戳
        counter = 0;
        timestamp = now;
        return true;
    }
}

但是，这种算法有一个很明显的临界问题：假设限流阀值为5个请求，单位时间窗口是1s,如果我们在单位时间内的前0.8-1s和1-1.2s，分别并发5个请求。虽然都没有超过阀值，但是如果算0.8-1.2s,则并发数高达10，已经超过单位时间1s不超过5阀值的定义啦。
在这里插入图片描述

二，滑动窗口限流算法

滑动窗口限流解决固定窗口临界值的问题。它将单位时间周期分为n个小周期，分别记录每个小周期内接口的访问次数，并且根据时间滑动删除过期的小周期。

一张图解释滑动窗口算法，如下：
在这里插入图片描述
我们来看下滑动窗口是如何解决临界问题的？

假设单位时间还是1s，滑动窗口算法把它划分为5个小周期，也就是滑动窗口（单位时间）被划分为5个小格子。每格表示0.2s。每过0.2s，时间窗口就会往右滑动一格。然后呢，每个小周期，都有自己独立的计数器，如果请求是0.83s到达的，0.8~1.0s对应的计数器就会加1。

TIPS: 当滑动窗口的格子周期划分的越多，那么滑动窗口的滚动就越平滑，限流的统计就会越精确。

滑动窗口算法代码实现如下：

public class SlidingWindowRateLimiter implements RateLimiter {
    // 每分钟限制的请求数
    private final long permitsPerMinute;

    // 计数器，k为当前窗口的开始时间值秒，value为当前窗口的计数
    private final TreeMap<Long, Integer> counters;

    public SlidingWindowRateLimiter(long permitsPerMinute) {
        this.permitsPerMinute = permitsPerMinute;
        this.counters = new TreeMap<>();
    }

    @Override
    public synchronized boolean tryAcquire() {
        // 获取当前时间所在的子窗口值；10s一个窗口
        long currentWindowTime = LocalDateTime.now().toEpochSecond(ZoneOffset.UTC) / 10 * 10;
        // 获取当前窗口的请求总量
        int currentWindowCount = getCurrentWindowCount(currentWindowTime);
        if (currentWindowCount >= permitsPerMinute) {
            return false;
        }
        // 计数器加一
        counters.merge(currentWindowTime, 1, Integer::sum);
        return true;
    }

    /**
     * 获取当前窗口的所有请求数（并删除所有无效的子窗口计数器）
     *
     * @param currentWindowTime 当前子窗口时间
     * @return 当前窗口中的计数
     */
    private int getCurrentWindowCount(long currentWindowTime) {
        // 计算出窗口的开始位置时间
        long startTime = currentWindowTime - 50;
        int result = 0;
        // 遍历当前存储的计数器，删除无效的子窗口计数器，并累加当前窗口中的所有计数器之后
        Iterator<Map.Entry<Long, Integer>> entryIterator = counters.entrySet().iterator();
        while (entryIterator.hasNext()) {
            Map.Entry<Long, Integer> entry = entryIterator.next();
            if (entry.getKey() < startTime) {
                entryIterator.remove();
            } else {
                result += entry.getValue();
            }
        }
        return result;
    }
}

三，令牌桶限流算法

面对突发流量的时候，我们可以使用令牌桶算法限流。

令牌桶算法原理：

  • 有一个令牌管理员，根据限流大小，定速往令牌桶里放令牌。
  • 如果令牌数量满了，超过令牌桶容量的限制，那就丢弃。
  • 系统在接受到一个用户请求时，都会先去令牌桶要一个令牌。如果拿到令牌，那么就处理这个请求的业务逻辑；
  • 如果拿不到令牌，就直接拒绝这个请求。

在这里插入图片描述
令牌桶算法代码实现如下：

public class TokenBucketRateLimiter implements RateLimiter {
    // 令牌桶的容量
    private final long capacity;
    // 令牌发放速率
    private final long generatedPerSecond;
    // 最后一个令牌发放的时间
    private long lastTokenTime = System.currentTimeMillis();
    // 当前令牌数量
    private long currentTokens;

    public TokenBucketRateLimiter(long capacity, long generatedPerSecond) {
        this.capacity = capacity;
        this.generatedPerSecond = generatedPerSecond;
    }

    @Override
    public synchronized boolean tryAcquire() {
        /*
          计算当前令牌的数量
          请求时间在最后令牌产生的时间相差大于等于1s
          1.重新计算令牌桶中的令牌数量
          2. 将最后一个令牌发放时间重置为当前时间
         */
        long now = System.currentTimeMillis();
        if (now - lastTokenTime >= 1000) {
            long newPermits = (now - lastTokenTime) / 1000 * generatedPerSecond;
            currentTokens = Math.min(currentTokens + newPermits, capacity);
            lastTokenTime = now;
        }
        if (currentTokens > 0) {
            currentTokens--;
            return true;
        }
        return false;
    }
}

四，漏桶限流算法

漏桶算法面对限流，就更加的柔性，不存在直接的粗暴拒绝。

它的原理很简单，可以认为就是注水漏水的过程。往漏桶中以任意速率流入水，以固定的速率流出水。当水超过桶的容量时，会被溢出，也就是被丢弃。因为桶容量是不变的，保证了整体的速率。
在这里插入图片描述

  • 流入的水滴，可以看作是访问系统的请求，这个流入速率是不确定的。
  • 桶的容量一般表示系统所能处理的请求数。
  • 如果桶的容量满了，就达到限流的阀值，就会丢弃水滴（拒绝请求）
  • 流出的水滴，是恒定过滤的，对应服务按照固定的速率处理请求。

漏桶算法代码实现如下：

public class LeakyBucketRateLimiter implements RateLimiter {
    // 桶的容量
    private final int capacity;
    // 漏出的速率
    private final int permitsPerSecond;
    // 剩余水量
    private long leftWater;
    // 上次注入水的时间
    private long timeStamp = System.currentTimeMillis();

    public LeakyBucketRateLimiter(int capacity, int permitsPerSecond) {
        this.capacity = capacity;
        this.permitsPerSecond = permitsPerSecond;
    }

    @Override
    public synchronized boolean tryAcquire() {
        // 计算剩余水量
        long now = System.currentTimeMillis();
        long timeGap = (now - timeStamp) / 1000;
        leftWater = Math.max(0, leftWater - timeGap * permitsPerSecond);
        timeStamp = now;
        // 如果未满，则放行；否则限流
        if (leftWater < capacity){
            leftWater += 1;
            return true;
        }
        return false;
    }
}

这并不是一个完整的漏桶算法的实现，以上代码中只是对流量是否会被抛弃进行校验，即tryAcquire返回true表示漏桶未满，否则表示漏桶已满丢弃请求。

想要以恒定的速率漏出流量，通常还应配合一个FIFO队列来实现，当tryAcquire返回true时，将请求入队，然后再以固定频率从队列中取出请求进行处理。示例代码如下：

@Test
public void testLeakyBucketRateLimiter() throws InterruptedException {
    ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
    ExecutorService singleThread = Executors.newSingleThreadExecutor();

    LeakyBucketRateLimiter rateLimiter = new LeakyBucketRateLimiter(20, 20);
    // 存储流量的队列
    Queue<Integer> queue = new LinkedList<>();
    // 模拟请求  不确定速率注水
    singleThread.execute(() -> {
        int count = 0;
        while (true) {
            count++;
            boolean flag = rateLimiter.tryAcquire();
            if (flag) {
                queue.offer(count);
                System.out.println(count + "--------流量被放行--------");
            } else {
                System.out.println(count + "流量被限制");
            }
            try {
                Thread.sleep((long) (Math.random() * 1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });

    // 模拟处理请求 固定速率漏水
    scheduledExecutorService.scheduleAtFixedRate(() -> {
        if (!queue.isEmpty()) {
            System.out.println(queue.poll() + "被处理");
        }
    }, 0, 100, TimeUnit.MILLISECONDS);

    // 保证主线程不会退出
    while (true) {
        Thread.sleep(10000);
    }
}

漏桶算法存在目的主要是用来平滑突发的流量，提供一种机制来确保网络中的突发流量被整合成平滑稳定的额流量。

不过由于漏桶对流量的控制过于严格，在有些场景下不能充分使用系统资源，因为漏桶的漏出速率是固定的，即使在某一时刻下游能够处理更大的流量，漏桶也不允许突发流量通过。

五，滑动日志限流算法

滑动日志是一个比较“冷门”，但是确实好用的限流算法。滑动日志限速算法需要记录请求的时间戳，通常使用有序集合来存储，我们可以在单个有序集合中跟踪用户在一个时间段内所有的请求。

假设我们要限制给定T时间内的请求不超过N，我们只需要存储最近T时间之内的请求日志，每当请求到来时判断最近T时间内的请求总数是否超过阈值。
在这里插入图片描述![

滑动日志算法代码实现如下：


public class SlidingLogRateLimiter implements RateLimiter {
    // 每分钟限制的请求数
    private static final long PERMITS_PER_MINUTE = 60;
    // 请求日志计数器，k-为请求的时间（秒），value当前时间的请求数量
    private final TreeMap<Long, Integer> requestLogCountMap = new TreeMap<>();

    @Override
    public synchronized boolean tryAcquire() {
        // 最小时间粒度为秒
        long currentTimeStamp = LocalDateTime.now().toEpochSecond(ZoneOffset.UTC);
        // 获取当前窗口的请求总数
        int currentWindowCount = getCurrentWindowCount(currentTimeStamp);
        if (currentWindowCount >= PERMITS_PER_MINUTE) {
            return false;
        }
        // 请求成功，将当前请求日志加入到日志计数器中
        requestLogCountMap.merge(currentTimeStamp, 1, Integer::sum);
        return false;
    }

    /**
     * 统计当前时间窗口内的请求数
     *
     * @param currentTimeStamp 当前时间
     * @return 请求数
     */
    private int getCurrentWindowCount(long currentTimeStamp) {
        // 计算出窗口的开始位置时间
        long startTime = currentTimeStamp - 59;
        // 遍历当前存储的计数器，删除无效的子窗口计数器，并累加当前窗口中的所有计数器之和
        return requestLogCountMap.entrySet()
                .stream()
                .filter(entry -> entry.getKey() >= startTime)
                .mapToInt(Map.Entry::getValue)
                .sum();
    }


}

滑动日志能够避免突发流量，实现较为精准的限流；同样更加灵活，能够支持更加复杂的限流策略，如多级限流，每分钟不超过100次，每小时不超过300次，每天不超过1000次，我们只需要保存最近24小时所有的请求日志即可实现。

灵活并不是没有代价的，带来的缺点就是占用存储空间要高于其他限流算法。

活跃的咸鱼
关注
专栏目录
【微服务】springboot 通用限流方案设计与实现
congge
06-24 8659
springboot限流方案总结
基于Redis的分布式限流器Java实现
GaleZhang的博客
08-23 3280
限流、熔断与降级是系统应对海量并发时进行自我保护的三大“神器”。其中限流作为常见的业务场景，在一些小型系统中也是存在一定的需求。对于Java而言，常见的开源限流组件，如Guava RateLimiter，通过线程同步实现限流，仅适用于单机应用，而像阿里的Sentinel等，对小型应用来说又未免过重。本文通过Redis实现了分布式限流器，支持加载不同的脚本进行简单计数器、滑动窗口以及漏桶限流方案，并通过注解的方式对接口进行限流，既实现了对业务代码的极低侵入，又可以定制化限流逻辑。在这里与各位同学分享，也希望大
java的限流算法
qq_45062447的博客
09-23 659
** Java限流算法** 概要 在大数据量高并发访问时，经常会出现服务或接口面对暴涨的请求而不可用的情况，甚至引发连锁反映导致整个系统崩溃。此时你需要使用的技术手段之一就是限流，当请求达到一定的并发数或速率，就进行等待、排队、降级、拒绝服务等。 在开发高并发系统时，有三把利器用来保护系统：缓存、降级和限流： 缓存：缓存的目的是提升系统访问速度和增大系统处理容量...
Java常见的限流算法
qq_33807380的博客
12-28 900
在分布式系统中，高并发场景下，为了防止系统因突然的流量激增而导致的崩溃，同时保证服务的高可用性和稳定性，限流是最常用的手段。常见的限流算法主要有：固定窗口算法、滑动窗口算法、漏桶算法、令牌桶算法。
【java】常见限流算法原理及应用
最新发布
qq_62095670的博客
09-20 1222
在现代分布式系统和高并发场景下，限流已成为保障系统稳定性和可用性的重要手段。随着互联网应用规模的不断扩大，系统经常会面对海量请求和突发流量，如何有效控制和管理这些请求流量成为一项关键挑战。限流算法作为流量控制的重要工具，能够帮助系统平衡资源分配、抵御恶意攻击，并在高峰期维持服务的连续性与可靠性。本文将深入探讨几种常见的限流算法及其应用场景，帮助读者更好地理解限流机制的工作原理与优化策略。
常用限流算法的Java实现
Huangjiazhen711的博客
11-26 458
主要内容为三种限流算法的Java实现获取连接许可的接口。
Java项目如何实现限流？
chenxuyuana的博客
07-05 1536
众所周知，服务器能处理的请求数是有限的，如果请求量特别大，我们就可能需要做限流。限流处理的姿势：要么就让请求等待，要么就把请求给扔了从系统架构来看，我们的统一处理入口在接入层上，接入层做完简单的参数校验以及参数拼接后，就将请求转发到消息队列上了image.png按正常来说，因为接了消息队列且接入层没有什么耗时的操作，那对外的接口压力不大的。没错的，austin要接入限流也并不是在接入层上做，是在消息处理下发层。消息处理下发层我们是用线程池去隔离不同的消息渠道不同的消息类型。在系统本身上其实没有性能相关的问题
Java限流实现
04-24
NULL 博文链接：https://bijian1013.iteye.com/blog/2382409
Java高频面试题：四种经典限流算法，有哪四种？
程序媛小琬的博客
12-01 726
四种经典限流算法你都知道吗？
四、高并发系统限流大法——限流算法：漏桶算法
流楚丶格念的博客
08-20 889
漏桶算法是一种用于流量控制的算法，通过一个“漏桶”来处理请求。请求被放入桶中，桶以固定速率“漏出”请求。如果桶满了，新请求将被丢弃或延迟。漏桶算法适用于需要平稳输出请求速率的场景，能够有效控制流量和负载。
分析常见限流算法及手写三种（计数器、漏斗、令牌桶）代码实现
Java_LingFeng的博客
12-05 764
常见的限流算法分析限流在我们日常生活中经常见到，如火车站门口的栏杆、一些景点的门票只出售一定的数量 等等。在我们的开发中也用到了这种思想。为什么要限流🏫在保证可用的情况下尽可能多增加进入的人数,其余的人在排队等待,或者返回友好提示,保证里面的进行系统的用户可以正常使用， 防止系统雪崩。限流算法🌴🌴限流算法很多,常见的有三类,分别是 计数器算法 、漏桶算法、令牌桶算法 。
基于令牌桶算法的Java限流实现
02-23
基于令牌桶算法的Java限流实现。 项目需要使用限流措施，查阅后主要使用令牌桶算法实现，为了更灵活的实现限流，就自己实现了一个简单的基于令牌桶算法的限流实现。
java实现令牌桶限流
09-11
限流是对某一时间窗口内的请求数进行限制，保持系统的可用性和稳定性，防止因流量暴增而导致的系统运行缓慢或宕机。常用的限流算法有令牌桶和和漏桶，而Google开源项目Guava中的RateLimiter使用的就是令牌桶控制算法。 在开发高并发系统时有三把利器用来保护系统：缓存、降级和限流
java 滑动窗口算法_Java 实现滑动时间窗口限流算法的代码
weixin_34782968的博客
02-13 1218
在网上搜滑动时间窗口限流算法，大多都太复杂了，本人实现了个简单的，先上代码：package cn.dijia478.util;import java.time.LocalTime;import java.util.LinkedList;import java.util.List;import java.util.Map;import java.util.Random;import java.uti...
Java常见限流用法介绍和实现
YY-帆S的博客
03-27 4087
在固定时间窗口的基础上进行优化，对大的时间窗口进行划分，每个小窗口对应大窗口中的不同时间点，每个窗口独立计数。又如在最后1个毫秒内请求了100个请求，下一个毫秒开始新的时间窗口，计数清0，此时又涌入了100个请求，虽说固定时间窗口内没有超过阈值，但是全局看来，这两个毫秒内就涌入了200个请求，对于限流100的概念是不可接受的。与漏桶算法相反，系统以固定的速率往桶里放入令牌，称为令牌桶，如果有请求需要这个令牌，这可以从桶里拿一个，拿到了令牌即允许放行，直到令牌被拿完即令牌不足，则请求需等待或被丢弃。
Java中常用的限流算法
zhaodongchao的博客
11-24 2231
在Java的系统中，在一些活动日或者是被黑客攻击，导致访问量突然暴增，系统承受不了巨大的流量冲击而崩溃。为了保护我们的系统，在实际开发中有四种常见的限流算法来保证系统的安全性。 1 固定窗口算法 固定窗口算法的原理很简单。就是在时间轴上，限制单位时间内的请求数量。 实现步骤如下： 1. 使用一个计数器记录单位时间内的访问数量 2. 当访问数量没有达到阀值，就允许访问；当访问数量达到阀值，就拒绝访问 3. 当时间窗口过去后，计数器重新计数。 实现很简单，但也存在问题。假设时间窗口大小为1秒，窗口内限制的请
一文详解 Java 限流常见的四种限流算法
weixin_45583158的博客
01-17 1566
一、限流为什么要进行限流？1.瞬时流量过高，服务被压垮？2.恶意用户高频光顾，导致服务器宕机？3.消息消费过快，导致数据库压力过大，性能下降甚至崩溃？……什么是限流？限流是对某一时间窗口内的请求数进行限制，保持系统的可用性和稳定性，防止因流量暴增而导致的系统运行缓慢或宕机。在高并发系统中，出于系统保护角度考虑，通常会对流量进行限流。在分布式系统中，高并发场景下，为了防止系统因突然的流量激增而导致的...
令牌桶算法限流
weixin_33819479的博客
07-27 783
限流 限流是对某一时间窗口内的请求数进行限制，保持系统的可用性和稳定性，防止因流量暴增而导致的系统运行缓慢或宕机。常用的限流算法有令牌桶和和漏桶，而Google开源项目Guava中的RateLimiter使用的就是令牌桶控制算法。 在开发高并发系统时有三把利器用来保护系统：缓存、降级和限流 缓存：缓存的目的是提升系统访问速度和增大系统处理容量 降级：降级是当服务器压力剧增的情况下，根据...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

活跃的咸鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值