四种限流算法以及限流实践

最新推荐文章于 2024-07-13 23:05:26 发布
最新推荐文章于 2024-07-13 23:05:26 发布
阅读量725 收藏 25
点赞数 29
文章标签： 算法 redis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79108772/article/details/140403002
版权

1.固定时间窗口限流算法

        在固定时间内进行限流，比如下午1点到下午2点只允许用户进行操作十次，那如果超过这十次就会拒绝用户进行访问。

        问题：可能会出现流量突刺，如果用户正好卡在1点59分59秒进行十次访问，在2点00分00秒又进行了十次访问，那用户就在极短的时间内进行了多次访问，产生了流量突刺。

        简单进行实现固定窗口限流。

        统计限流次数使用常量即可。

import org.junit.jupiter.api.Test;

import java.time.LocalDateTime;
import java.time.ZoneOffset;

public class FixedTimeWindows {

    public static long recordTime = LocalDateTime.now().toEpochSecond(ZoneOffset.UTC) * 1000;

    /**
     * 获取限流的时间戳 毫秒 十秒内只能访问五次
     */
    public static final long LIMIT_TIME = LocalDateTime.now().plusSeconds(10).toEpochSecond(ZoneOffset.UTC) * 1000 - recordTime;

    /**
     * 定义一小时能可以进行调用的次数
     */
    public static final int LIMIT_TIMES = 5;

    /**
     * 存储用户调用的次数
     */
    public static int userTimes = 0;

    /**
     * 实现固定窗口限流算法
     */
    public static boolean fixedTimeWindowLimit() {
        // 获取当前时间
        long now = LocalDateTime.now().toEpochSecond(ZoneOffset.UTC) * 1000;

        if (now - recordTime > LIMIT_TIME) {
            // 更新时间限制
            System.out.println("更新时间限制");
            userTimes = 0;
            recordTime = now;
        } else {
            if (userTimes >= LIMIT_TIMES) {
                return false;
            }
        }
        userTimes++;
        return true;
    }

    public static void getNiuma() {
        System.out.println("牛马");
    }

    @Test
    void testGetNiuma() throws InterruptedException {

        for (int i = 0; i <= 20; i++) {
            Thread.sleep(1 * 1000);
            boolean result = fixedTimeWindowLimit();
            if (!result) {
                System.out.println("超出调用限制");
            } else {
                getNiuma();
            }
        }
    }
}

2.滑动时间窗口限流算法

        设定一个单位时间：一小时内只能有十次访问，在黄色期间的一小时只能进行访问十次，当时间发生变化向后推迟了十分中，在紫色范围能只能访问十次。

        这种算法巧妙的避免了流量突刺的情况，即使你分两段对我进行多次访问，只要这两段访问时间在我的单位时间单元内，那我就可以使用流量阻塞，不让你进行访问。

        优点：可以解决上述流量突刺的问题。

        缺点：实现相对复杂，限流效果和你的滑动单位有关，滑动单位越小，限流效果越好，但是往往很难进行选择一个特别合适的滑动单位。而且会直接暴力拒绝请求，比较影响用户的体验性。

        简单实现滑动窗口限流。

        统计限流次数使用数组进行滑动时间处理。

import org.junit.jupiter.api.Test;

import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.Arrays;

public class SlideTimeWindow {

    /**
     * 定义初始化记录的事件
     */
    public static long recordTime = LocalDateTime.now().toEpochSecond(ZoneOffset.UTC) * 1000;

    /**
     * 获取限流的时间戳 毫秒 十秒内内只能访问五次
     */
    public static final long LIMIT_TIME = LocalDateTime.now().plusSeconds(10).toEpochSecond(ZoneOffset.UTC) * 1000 - recordTime;

    /**
     * 分割为十个时间单位
     */
    public static final int UNITS_OF_TIME = 10;

    /**
     * 定义一小时能可以进行调用的次数
     */
    public static final int LIMIT_TIMES = 5;

    /**
     * 存储用户调用的次数
     */
    public static int[] userTimeArr = new int[UNITS_OF_TIME];

    /**
     * 数组求和
     */
    public static int arrSum() {
        return Arrays.stream(userTimeArr).sum();
    }

    /**
     * 根据时间进行数组清零
     * @param number 时间
     */
    public static void arrCleanZero(int number) {
        for (int i = 0; i <= number; i++) {
            userTimeArr[i] = 0;
        }
    }

    /**
     * 定义滑动窗框限流
     */
    public static boolean slideTimeWindowLimit() {
        // 获取当前时间
        long now = LocalDateTime.now().toEpochSecond(ZoneOffset.UTC) * 1000;

        // 1. 当前时间 - 上次调用记录时间 > 10秒 清零 -> 允许调用
        if (now - recordTime >= LIMIT_TIME) {
            userTimeArr = new int[UNITS_OF_TIME];
        }

        // 2. 当前时间 - 上次调用记录时间 < 10秒
        if (now - recordTime < LIMIT_TIME) {
            // 2.1 数组求和 > 限制次数 滚蛋
            if (arrSum() >= LIMIT_TIMES) {
                // 一定要更新记录时间
                recordTime = now;
                return false;
            }
            // 2.2 数组求和 < 限制次数 允许调用
        }
        // 3. 调用规整

        // 3.0 给哪个时间加这个次数
        int timeNumber = (int) Math.floor((double) (now - recordTime) / 1000);
        // 处理过界情况
        if (timeNumber > 10) {
            timeNumber -= 10;
        }
        
        // 3.1 统一进行加1
        userTimeArr[timeNumber] += 1;
        // 3.2 更新记录时间
        recordTime = now;

        return true;
    }

    public static void getNiuma() {
        System.out.println("牛马");
    }

    @Test
    void testGetNiuma() throws InterruptedException {
        boolean result;

        for (int i = 0; i <= 10; i++) {
            Thread.sleep(500);
            result = slideTimeWindowLimit();
            if (!result) {
                System.out.println("超出调用限制");
            } else {
                getNiuma();
            }
        }

        Thread.sleep(5000);

        for (int i = 0; i <= 10; i++) {
            Thread.sleep(500);
            result = slideTimeWindowLimit();
            if (!result) {
                System.out.println("超出调用限制");
            } else {
                getNiuma();
            }
        }

        Thread.sleep(10000);

        for (int i = 0; i <= 10; i++) {
            Thread.sleep(500);
            result = slideTimeWindowLimit();
            if (!result) {
                System.out.println("超出调用限制");
            } else {
                getNiuma();
            }
        }
    }
}

3.漏桶限流算法

        漏桶算法就是定义一个桶，进行存储请求流量，但是出桶进行处理请求的时候，是根据固定速率出来请求进行处理。

        桶有一定的容量，如果请求存储到漏桶中，超出了容量，就会进行拒绝请求。

        优点：在一定程度上可以应对流量突刺，能够固定速率处理请求，保证服务器的安全。

        缺点：无法迅速处理一批请求，只能一个一个按顺序来处理（固定速率的缺点），当系统出现流量高峰的时候，还这样处理速度不变，对用户的体验会非常不好。

        简单实现漏桶限流算法。

import java.util.ArrayList;
import java.util.List;

public class LeakyBuckets {

    /**
     * 定义固定速率
     */
    public static final int SPEED = 1;

    /**
     * 定义桶容量
     */
    public static final int CAPACITY = 10;

    /**
     * 定义桶
     */
    public static List<Integer> bucketArr = new ArrayList<>();

    /**
     * 定义漏桶限流
     * false 执行限流 true 不执行限流
     * @return
     */
    public static boolean leakyBucketsLimit() {
        // 1. 将请求加入到漏桶中
        // 判断桶是否满了
        if (bucketArr.size() >= CAPACITY) {
            // 执行限流
            System.out.println("============== 桶满啦 ==============");
            return false;
        }
        // 实际过程中可以进行加入请求标识等
        bucketArr.add(1);

        // 2. 以固定流速进行处理请求
        // 这里只进行实现单线程的 实际请求中固定速率高的时候应该开多线程
        return true;
    }

    public static void getNiuma() {
        System.out.println("牛马");
    }
}

4.令牌桶限流算法

        就是管理员先进行生成一批令牌，每秒生成10个令牌，当用户要进行操作前，先去拿到一个令牌，有令牌的人才有资格进行操作，能同时进行操作，拿不到令牌的就需要进行等着。

        实现令牌桶算法。

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {

    private String name;

    public MyCallable(String name) {
        this.name = name;
    }

    @Override
    public String call() throws Exception {
        return TokenBucket.getNiuma(name);
    }
}
import org.junit.jupiter.api.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class TokenBucket {

    /**
     * 定义固定速率
     */
    public static final int SPEED = 1;

    /**
     * 定义令牌前缀
     */
    public static final String TOKEN_FRONT = "token";

    /**
     * 定义令牌桶
     */
    public static List<String> tokenBucket = new ArrayList<>();

    /**
     * 生成令牌
     * @param key 关键key
     */
    public static String productToken(String key) {
        String token = TOKEN_FRONT + key;
        tokenBucket.add(token);
        return token;
    }


    /**
     * 初始化令牌
     * @param number 初始化令牌数量
     */
    public static void initToken(int number) {
        for (int i = 0; i < number; i++) {
            productToken("niuma" + i);
        }
    }

    /**
     * 校验令牌
     * @param token 令牌
     * @return false 限流 true 成功
     */
    public static boolean tokenBucketLimit(String token) {
        // 校验无令牌
        if (token == null || token.isEmpty() || token.equals(" ") || !tokenBucket.contains(token)) {
            return false;
        }

        return true;
    }

    public static String getNiuma(String name) {
        return "线程名: " + name + ", 牛马。";
    }

    @Test
    void testGetNiuma() throws ExecutionException, InterruptedException {
        // 初始化令牌
        initToken(3);

        // 初始化多线程
        MyCallable callable1 = new MyCallable("线程1");
        MyCallable callable2 = new MyCallable("线程2");
        FutureTask<String> futureTask1 = new FutureTask<>(callable1);
        FutureTask<String> futureTask2 = new FutureTask<>(callable2);

        // 校验令牌
        if (tokenBucketLimit(TOKEN_FRONT + "niuma1")) {
            new Thread(futureTask1).start();
            new Thread(futureTask2).start();
            System.out.println(futureTask1.get());
            System.out.println(futureTask2.get());
        }

        if (tokenBucketLimit("duaisbdiasu")) {
            new Thread(futureTask2).start();
            System.out.println(futureTask2.get());
        }
    }
}

        优点：能够并发处理同时的请求，并发性能会更高，因为在低流量的时候可以进行积攒令牌，高流量的时候，积攒了足够的令牌可以应对高并发的请求，解决了漏桶算法的问题。

        需要考虑的问题：还是存在时间单位选取的问题。如果流量突刺时令牌数量超过了系统可以进行接收的流量最大范围，那服务器就挂了，如果太少就会拒绝请求，导致用户体验过差。

5.限流粒度

        1.针对某个方法进行限流，即单位时间内最多允许同时XX个操作使用这个办法。

        2.针对某个用户进行限流，比如单个用户单位时间内最多执行XX次操作。

        3.针对某个用户X方法进行限流，比如单个用户时间内最多执行XX次这个方法。

6.四种限流算法的思考

        对于针对用户限流最大的问题就是，如果此时DDOS攻击者调动大量肉鸡，对我们的系统进行进攻，我们的限流如果仅仅针对用户的调用次数进行限流，并采用对用户进行限流的算法，那么我们的系统会被大量肉鸡产生的流量突刺，会占用大量服务器资源，直接突破我们的系统。

        所以我们就是不仅要对用户在操作接口时进行限流操作，更要在对每个接口进行限流。

        对于每个用户的限流就是为了防止DDOS攻击者操控一个用户大量进行请求，占用我们的资源，使得其他用户无法进行张昌访问。

        对于接口（全部用户）进行限流是为了防止接口遭遇流量突刺，因为如果我们仅仅对一个用户进行限流，DDOS攻击者，操控多个用户对我们发起突刺，也会沾满我们的系统，所以我们要对整个系统的接口进行限流。

        而且我们可以进行监控用户的操作，如果用户的操作，并非正常行为（比如持续高输出）那我们可以立刻对其进行封锁，限制用户行为，监控的话，我们可以使用AOP（单机）或者网关（分布式）。

7.本地限流实现（单机限流）

        每个服务器进行单独限流，一般适用于单体项目，就是你得项目只有一个服务器。

        使用Guava RateLimiter实现单机限流。

        底层使用的是令牌桶算法。

8.分布式限流实现（多机限流）

        如果你的项目有多个服务器，比如微服务，那么建议使用分布式限流。

        1.把用户的使用频率等数据放到一个集中的存储中进行统计，比如Redis，这样无论用户的请求落到了哪台服务器，都可以以集中的数据存储内的数据为准（Redisson）。

        2.在网关中集中进行限流和统计（比如Sentinel，Spring Cloud Gateway）。

        redisson底层进行限流的时候使用的也是令牌桶算法进行限流。

9.使用redisson实现限流

9.1Redisson限流实现

        Redission内置了一个限流工具类，可以帮助你利用Redis来存储，来统计。

9.2Redisson的实现

9.2.1本地/远程安装Redis

        Redission依赖于Redis所以需要进行安装Redis进行使用。

9.2.2引入Redisson的依赖

<!-- https://github.com/redisson/redisson#quick-start -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.21.3</version>
</dependency>

9.2.3实现Redisson的配置

import lombok.Data;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConfigurationProperties(prefix = "spring.redis")
@Data
public class RedissonConfig {

    private Integer database;

    private String host;

    private Integer port;

    private String username;

    private String password;

    @Bean
    public RedissonClient getRedissonClient() {
        Config config = new Config();
        // 设置使用redis单机 设置数据库和地址
        config.useSingleServer()
                .setDatabase(database)
                .setAddress("redis://" + host + ":" + port);
        RedissonClient redissonClient = Redisson.create(config);
        return redissonClient;
    }
}

9.2.4实现限流操作

import com.yang.yangbi.common.ErrorCode;
import com.yang.yangbi.exception.BusinessException;
import org.redisson.api.RRateLimiter;
import org.redisson.api.RateIntervalUnit;
import org.redisson.api.RateType;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class RedisLimitManager {

    @Resource
    private RedissonClient redissonClient;

    /**
     * 限流操作
     *
     * @param key 区分不同的限流器
     */
    public void doRateLimit(String key) {
        // 创建一个名称为user_limiter的限流器, 每秒最多访问两次
        RRateLimiter rateLimiter = redissonClient.getRateLimiter(key);
        rateLimiter.trySetRate(RateType.OVERALL, 2, 1, RateIntervalUnit.SECONDS);
        // 每当一个操作来了之后, 请求一个令牌
        boolean canOp = rateLimiter.tryAcquire(1);
        if (!canOp) {
            throw new BusinessException(ErrorCode.TOO_MANY_REQUEST);
        }
    }
}

9.2.5进行单元测试

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;

@SpringBootTest
class RedisLimitManagerTest {

    @Resource
    private RedisLimitManager redisLimitManager;

    @Test
    void doRateLimit() throws InterruptedException {
        String userId = "999";
        for (int i = 0; i < 2; i++) {
            redisLimitManager.doRateLimit(userId);
            System.out.println("成功");
        }
        Thread.sleep(1000);
        for (int i = 0; i < 5; i++) {
            redisLimitManager.doRateLimit(userId);
            System.out.println("成功");
        }
    }
}

10.结语

        没想到自己居然听了一天白羊，麻了....

我不是星海
关注
  • 29
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
详解Springboot分布式限流实践
08-25
限流算法是分布式限流实践的核心部分，常见的限流算法有令牌桶算法、漏桶算法、计数器限流算法等。 1. 令牌桶算法 令牌桶算法的原理是系统会以一个恒定的速度往桶里放入令牌，而如果请求需要被处理，则需要先从桶...
redis限流算法.zip
07-03
在这个“redis限流算法.zip”压缩包中，我们能看到几个关键的限流算法实现，包括计数法、令牌桶算法，以及基于Redis的漏斗算法的思路。这些算法在高并发场景下尤其重要，能够防止系统过载，保持服务的稳定性和可靠性...
网关限流算法及实现总结
冒烟儿的专栏
12-14 3904
在高并发的系统中，往往需要在系统中做限流，一方面是为了防止大量的请求使服务器过载，导致服务不可用，另一方面是为了防止网络攻击。 常见的限流场景有： 限制总并发数（比如数据库连接池、线程池） 限制瞬时并发数（如 nginx 的 limit_conn 模块，用来限制瞬时并发连接数） 限制时间窗口内的平均速率（如 Guava 的 RateLimiter、nginx 的 limit_req 模块，限制每...
解决方案：限流算法
chuanchengdabing的博客
08-16 1104
限流
【Redis】分布式限流与Redis实现限流的四种方式（Redis专栏启动）
小明的Java问道之路
12-11 5572
本文介绍分布式系统和分布式限流，我们现在的生产中的限流包括网关层的限流与Redis实现的限流策略，主要有基于Redis的 setnx 操作、List、zset实现的滑动窗口，以及Redis的Lua脚本实现分布式限流。
算法：限流之漏桶算法实现
xiaobaiPlayGame的专栏
10-30 1868
本章介绍漏桶Leaky Bucket算法在流量限速场景的原理，以及C++实现和相关测试验证。常见的限流算法有计数限流，固定窗口限流，滑动窗口限流，漏桶算发限流，令牌桶算法限流。漏桶算法是限流算法的一种，其原理是将待处理数据统一放在一个桶中，然后根据匀速从桶中拿出数据处理。漏桶算法可应用与多种场景，本章讲诉网络流程控制限制场景的使用，对外发的网络数据进行控制，限制外发的数据的最高流量。
c#：ocelot限流体验
10-24
Ocelot限流功能通常通过设置如QPS（每秒请求数）、滑动窗口、漏桶算法或令牌桶算法等规则来实现。开发者可以自定义限流策略，例如基于IP地址限制，或者根据API的不同路径设置不同的限流阈值。在C#中，Ocelot的配置...
详解springboot+aop+Lua分布式限流的最佳实践
08-19
漏桶算法是一种常用的限流方式，思路很简单，把水比作是请求，漏桶比作是系统处理能力极限，水先进入到漏桶里，漏桶里的水按一定速率流出，当流出的速率小于流入的速率时，由于漏桶容量有限，后续进入的水直接溢出...
基于并行免疫粒子群算法的限流措施优化.pdf
09-29
总结来说，这篇论文为电力系统限流措施的优化提供了一种创新的计算方法，即并行免疫粒子群算法。这种算法结合了生物免疫系统的理论和群体智能的思想，有效地解决了非线性优化问题，提高了算法的收敛性能，并在Matlab...
【代码随想录_Day27】509 斐波那契数 70 爬楼梯 746 使用最小花费爬楼梯
qq_43671872的博客
07-08 889
509 斐波那契数70 爬楼梯746 使用最小花费爬楼梯今天的题目难度不低，尽量还是写一些简洁代码 ^ _ ^
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
m0_74586426的博客
07-12 614
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
代码随想录算法训练营第33天
m0_62262158的博客
07-10 165
【代码】代码随想录算法训练营第33天。
【算法】平衡二叉树
最新发布
时清云的博客
07-13 915
难度：简单。
牛客小白月赛98 （个人题解）（补全）
Wzh20060111的博客
07-13 383
前言：昨天晚上自己一个人打的小白月赛（因为准备数学期末已经写烦了），题目难度感觉越来越简单了（不在像以前一样根本写不了一点，现在看题解已经能看懂一点了），能感受到自己在不断进步，希望在暑假能更努力一点吧，，少打点游戏，多学学算法，还有web的学习也要抓起来了，这几天不是在看高数就是在打游戏，感觉好堕落。
【代码随想录算法训练营第六十二天|卡码网53.寻宝（prim算法和kruskal算法）】
weixin_46281930的博客
07-09 480
kruskal算法以边为导向，先把边按照长度从小到大排序，然后一个个检查边的两个端点是否在同一个集合中（这里使用并查集判断），在同一个集合中就不加入这个边，不在的话就加入。可以把所有已经使用过的结点看作一个整体，然后把他们相接的结点的结点顶点边中进行选择，选择最短的一条边把该结点入树，某种程度来说也是一种贪心？1.选择当前最短入树结点；3.更新结点距离最小生成树的距离。
【代码随想录】【算法训练营】【第62天】 [卡码108]冗余连接 [卡码109]冗余连接II
weixin_54954007的博客
07-08 596
思路及算法思维，指路。题目来自。day 62，又是一个周一，ding~
Leetcode104.求二叉树的最大深度
知道这个有什么用？
07-10 314
【代码】Leetcode104.求二叉树的最大深度。
代码随想录算法训练营day76 | Floyd 算法精讲、A * 算法精讲
sunflowers11的博客
07-09 425
本次题目来自于卡码网。
Linux C语言基础 day6
没有百宝袋的哆啦A梦的博客
07-08 1364
套路：将数组中的第一个先设置成当前的最值，然后拿着当前的最值与数组中的任意一个元素进行比较，如果比较过程中，不满足条件，则更新最值，直到所有数据都跟最值比较一番后，得出最值。printf("当前数组的最大值为：%d, 在数组的第%d个位置\n", max, maxi+1);2.部分初始化：初始化元素的个数，小于数组的长度，此时，默认从前面元素进行初始化，没有初始化的元素用0补齐。//更新最值中的数据。3.特殊初始化：在定义数组并初始化时，可以不用给定数组的长度，数组的长度由初始化元素个数而定。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值