算法--限流算法

最新推荐文章于 2024-11-01 14:48:20 发布
最新推荐文章于 2024-11-01 14:48:20 发布
阅读量144 收藏
点赞数
分类专栏： 算法 文章标签： java 算法 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangchaodee/article/details/129170863
版权

一、限流的简介

在进行服务高可用设计时，为了避免突发的流量激增导致服务处理压力过大甚至造成的服务雪崩效应，往往会采用限流措施。从场景上看限流主要为了应对突发流量、恶意流量以及业务因素限制；限流策略上按端分类可以有请求端的限流、服务端的限流（侧重于入口）、微服务的限流（侧重于后端服务之间）；限流从算法上分类主要有固定时间窗算法、滑动时间窗算法、漏桶算法、令牌桶算法等。

二、限流算法的不同方式

固定时间窗算法 ： 基于一个确定起始时间（如按每分钟或每秒），用累计计数的方式统计时间段内的请求数量 ，在未达到上限值时允许请求通过让服务处理，在超出设定的上限值时拒绝请求，方式较为简单。

滑动时间窗算法： 由于固定时间窗算法在应对流量恰好落在前一区间尾端和后一区间前端这种场景时不能达到限流目的，所以优化衍生出用滑动窗口方式来动态维护时间窗口以达成限流。

漏桶算法：处于严格控制系统处理请求的频率，产生了漏桶方式的限流，漏桶中有水代表服务有能力处理请求，漏桶中滴漏出来的水滴代表了以相对稳定的间隔处理请求，在实际应用中也可以是将请求想象成是水滴，来了后就放入水桶（如果水桶满了则代表请求挤压达到上限，此时则做抛弃策略，防止过载），服务从漏洞中较为匀速的拿取水滴（请求）进行消费处理，达到较为良好的控制服务压力。

令牌桶算法：令牌桶相对于漏桶模式的区别在于将判断逻辑优先交给响应请求的表层，表层在响应请求时 需要优先从令牌桶中拿到令牌，能拿到则请求会被处理，拿不到则立刻做抛弃策略，快速返回，在流量高于限定时就会表现为请求部分失败，如果流量再增高，则整体失败率会逐步增高；同时由于令牌桶预先缓冲了一定数量的令牌在桶中，所以可以应对一些小规模突发流量。

三、代码的简略实现

固定时间窗算法

/**
 * @author : wangchaodee
 * @Description: 固定窗口限流方式
 * <p>
 * 参考 ：https://time.geekbang.org/column/article/243961
 */
public class FixWindowRate implements RateLimitStrategy {

    private Stopwatch stopwatch;
    private AtomicInteger currentCount = new AtomicInteger(0);

    private Lock lock = new ReentrantLock();

    public FixWindowRate() {
        this(Stopwatch.createStarted());
    }

    protected FixWindowRate(Stopwatch stopwatch) {
        this.stopwatch = stopwatch;
    }

   @Override
    public boolean canHandle(Request request) {
        int cur = currentCount.incrementAndGet();
        return cur <= LIMIT;
    }


    public TimerTask mockInnerTask(){

        TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
                try {
                    if (lock.tryLock(TRY_LOCK_TIMEOUT, TimeUnit.MILLISECONDS)) {
                        try {
                            // 间隔着才会重置
                            if (stopwatch.elapsed(TimeUnit.MILLISECONDS) > TimeUnit.SECONDS.toMillis(DURATION)) {
                                currentCount.set(0);
                                stopwatch.reset();
                                stopwatch.start();
                            }
                        } finally {
                            lock.unlock();
                        }
                    } else {
                        log.info(" canHandle() can not get lock  by lock timeout %s ms ", TRY_LOCK_TIMEOUT);
                        throw  new RateLimitException("lock not get,timeout");
                    }
                } catch (InterruptedException e) {
                    log.error(" canHandle() is interrupted bu lock timeout ");
                    throw  new RateLimitException("lock not get ,interrupted");
                }
            }
        };

        return timerTask;
    }
}

滑动时间窗算法


/**
 * @author : wangchaodee
 * @Description: 滑动窗口限流算法方式
 */
@Slf4j
public class SlidingWindowRate implements RateLimitStrategy{

    Deque<Long> deque ;

    Stopwatch stopwatch ;

    private Lock lock = new ReentrantLock();


    public SlidingWindowRate() {
        this(new ArrayDeque<Long>(LIMIT) ,Stopwatch.createStarted());
    }

    public SlidingWindowRate(Deque deque ,Stopwatch stopwatch) {
        this.deque = deque;
        this.stopwatch = stopwatch;
    }

    /**
     * 单点 每次都锁  消耗比较大
     * @param request
     * @return
     */
    @Override
    public boolean canHandle(Request request) {
        long now = stopwatch.elapsed(TimeUnit.MILLISECONDS);

        try {
            if (lock.tryLock(TRY_LOCK_TIMEOUT, TimeUnit.MILLISECONDS)) {
                try {
                    if(deque.size()< LIMIT){
                        deque.addLast(now);
                        return true ;
                    }else {
                        long interval  = now -  deque.getFirst();
                        // 大于限定时间 则表明限定时间内的 请求量小于阈值
                        if(interval >= TimeUnit.SECONDS.toMillis(DURATION)){
                            deque.removeFirst();
                            deque.addLast(now);
                            return true ;
                        }
                    }
                } finally {
                    lock.unlock();
                }
            } else {
                log.info(" canHandle() can not get lock  by lock timeout %s ms ", TRY_LOCK_TIMEOUT);
                throw  new RateLimitException("lock not get,timeout");
            }
        } catch (InterruptedException e) {
            log.error(" canHandle() is interrupted bu lock timeout ");
            throw  new RateLimitException("lock not get");
        }

        return false;
    }

   @Override
    public TimerTask mockInnerTask() {
        // 暂时不需要
        return null;
    }
}

漏桶算法


/**
 * @author : wangchaodee
 * @Description: 漏桶限流算法方式
 */
@Slf4j
public class LeakyBucketRate implements RateLimitStrategy{

    private Stopwatch stopwatch;
    private AtomicInteger currentCount = new AtomicInteger(0);

    private Lock lock = new ReentrantLock();

    public LeakyBucketRate() {
        this(Stopwatch.createStarted());
    }

    protected LeakyBucketRate(Stopwatch stopwatch) {
        this.stopwatch = stopwatch;
    }

    @Override
    public boolean canHandle(Request request) {
        int cur = currentCount.incrementAndGet();
        return cur <= LIMIT ;
    }

    public TimerTask mockInnerTask(){

        TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
                try {
                    if (lock.tryLock(TRY_LOCK_TIMEOUT, TimeUnit.MILLISECONDS)) {
                        try {
                            if (stopwatch.elapsed(TimeUnit.MILLISECONDS) > TimeUnit.SECONDS.toMillis(1)) {
                                int cur = currentCount.get() ;
                                int rate = LIMIT/DURATION ; // 消费速率
                                if(cur>=LIMIT){
                                    currentCount.set( LIMIT- rate);
                                }else {
                                    // 桶中消费   降为0 时不可消费
                                    currentCount.set(Math.max(cur- rate , 0));
                                }
                                stopwatch.reset();
                                stopwatch.start();
                            }
                        } finally {
                            lock.unlock();
                        }
                    } else {
                        log.info(" canHandle() can not get lock  by lock timeout %s ms ", TRY_LOCK_TIMEOUT);
                        throw  new RateLimitException("lock not get,timeout");
                    }
                } catch (InterruptedException e) {
                    log.error(" canHandle() is interrupted bu lock timeout ");
                    throw  new RateLimitException("lock not get ,interrupted");
                }
            }
        };

        return timerTask;
    }

}

令牌桶算法


/**
 * @author : wangchaodee
 * @Description: 令牌桶限流算法 模拟
 */
@Slf4j
public class TokenBucketRate implements RateLimitStrategy{

    private Stopwatch stopwatch;
    private AtomicLong lastHandled;
    private AtomicInteger tokenAmount = new AtomicInteger(0);

    private Lock lock = new ReentrantLock();

    public TokenBucketRate() {
        this(Stopwatch.createStarted());
    }

    protected TokenBucketRate(Stopwatch stopwatch) {
        this.stopwatch = stopwatch;
        lastHandled = new AtomicLong(stopwatch.elapsed(TimeUnit.MILLISECONDS));
    }

    @Override
    public boolean canHandle(Request request) {
        int cur = tokenAmount.decrementAndGet();
        return cur>=0;
    }

    public TimerTask mockInnerTask(){

        TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
                try {
                    if (lock.tryLock(TRY_LOCK_TIMEOUT, TimeUnit.MILLISECONDS)) {
                        try {
                            if (stopwatch.elapsed(TimeUnit.MILLISECONDS) > TimeUnit.SECONDS.toMillis(1)) {

                                int cur = tokenAmount.get();
                                int rate = LIMIT/DURATION;
                                if(cur<=0){
                                    // 令牌桶空了时  直接设置令牌
                                    tokenAmount.set(rate);
                                }else {
                                    // // 令牌桶非空时   累加令牌  但不能超上限
                                    tokenAmount.set(Math.min(LIMIT,cur + rate));
                                }
                                stopwatch.reset();
                                stopwatch.start();
                            }
                        } finally {
                            lock.unlock();
                        }
                    } else {
                        log.info(" canHandle() can not get lock  by lock timeout %s ms ", TRY_LOCK_TIMEOUT);
                        throw new RateLimitException("lock not get,timeout");
                    }
                } catch (InterruptedException e) {
                    log.error(" canHandle() is interrupted bu lock timeout ");
                    throw new RateLimitException("lock not get ,interrupted");
                }
            }
        };

        return timerTask;
    }
}

模拟测试



    private Map<Integer ,Integer> execute(RateLimitHandler rateLimitHandler , List<Request> requestList){


        ExecutorService executor= Executors.newFixedThreadPool(5);
        List<Callable<Map<Integer ,Integer>>> tasks = generateTasks(rateLimitHandler,requestList);

        for (int i = 0; i <threadNum ; i++) {
            executor.submit(tasks.get(i));
        }

        Map<Integer ,Integer> statusCount = new HashMap<>() ;
        try {
            for (int i = 0; i < threadNum; i++) {
                Map<Integer, Integer> taskRes = tasks.get(i).call();
                for (Map.Entry<Integer, Integer> res : taskRes.entrySet()) {
                    statusCount.put(res.getKey(), statusCount.getOrDefault(res.getKey(),0) + res.getValue());
                }
            }

        }catch (Exception e){
            System.out.println("get result error ");
        }

        return statusCount ;
    }

 @Test
    public void testFixRateLimit() {
        RateLimitHandler rateLimitHandler = new RateLimitHandler(new FixWindowRate());
        System.out.println("rate limit Strategy : " + rateLimitHandler.getStrategy().getClass().getSimpleName()) ;
        Stopwatch stopwatch = Stopwatch.createStarted() ;
        rateLimitHandler.schedule();
        Map<Integer ,Integer> statusCount =  execute(rateLimitHandler,generateBlankRequestList());
        System.out.println("time : " + stopwatch.elapsed(TimeUnit.MILLISECONDS));
        for (Map.Entry<Integer,Integer> res : statusCount.entrySet()) {
            System.out.printf("key %d , nums : %d \n ", res.getKey() ,res.getValue());
        }
    }

 汪超
关注
专栏目录
经典限流算法-窗口算法、漏桶算法、令牌桶算法
11-09
经典限流算法-窗口算法、漏桶算法、令牌桶算法
34-图算法-最大流算法1
08-03
最大流算法是图算法中的一个重要分支，主要用于解决网络流问题，即在有向图中找到从源点到汇点的最大流量。这个概念在实际生活中有着广泛的应用，例如在资源分配、通信网络设计、物流配送等领域都有其身影。在“西气...
多线程编程（一）：加减计算
银河架构师的博客
07-21 835
每次执行完之后，都会将计数器减1（countDownLatch.countDown()），在未执行完之前，处于等待状态（countDownLatch.await()）。这是因为多线程运行时为并发方式，也许线程尚未执行时，便输出了count的值，此时为初始值0。此时，就需要引入一个新的类，AtomicInteger，可以以原子方式更新int值。感谢您的阅读，我是银河架构师，十年饮冰，难凉热血，愿历尽千帆，归来仍是少年！运行一下，结果与预期一致，count在经过3次加1之后，最终结果为3。运行一下，结果为0。.
stopwatch 统计耗时工具
的博客
01-04 1193
stopwatch 统计耗时工具
stopwatch计时器统计程序耗时
笔记罢了
12-29 2418
stopwatch计时器统计程序耗时 一、使用Google Stopwatch 1、引入依赖：import com.google.common.base.Stopwatch; 2、基础用法： Stopwatch stopwatch = Stopwatch.createStarted(); //创建计时器并开始计时 doSomething(); log.info("doSomething 耗时: "+ stopwatch.toString()); //stopwatch.toString()会自动选用合适的时
guava 的Stopwatch 进行计时
SmileTimLi的博客
03-12 822
Stopwatch stopwatch = Stopwatch.createStarted(); long nanos = stopwatch.elapsed(TimeUnit.NANOSECONDS); long mills = stopwatch.elapsed(TimeUnit.MILLISECONDS); long seco...
java-Stopwatch-耗时打印
startyangu的博客
03-25 584
【代码】java-Stopwatch-耗时打印。
限流 - 滑动窗口算法
白羊座的橙子
03-18 1544
一、工作原理二、优缺点三、应用场景四、滑动窗口算法实现Java demo滑动窗口算法是一种动态的限流策略，它相比固定窗口算法提供了更加平滑和精确的流量控制。滑动窗口通过将时间窗口划分为更小的单位，能够更灵活地响应流量的变化，减少因固定窗口切换时可能出现的流量峰值。
lixd#daily-notes#限流算法1
07-25
1. 概述 2. 计数器 3. 漏桶算法 4. 令牌桶算法 5. 漏桶算法与令牌桶算法区别
大数据-算法-几何不等式与曲率流.pdf
04-17
《大数据-算法-几何不等式与曲率流》这篇文档涵盖了多个数学和计算机科学领域的核心概念，主要围绕几何不等式、曲率流以及它们在大数据分析中的潜在应用展开。以下是这些知识点的详细说明： 1. **几何不等式**： -...
高级算法-nju-onlineJudge-master-java和python的答案
06-15
在本资源中，“高级算法-nju-onlineJudge-master-java和python的答案”主要涵盖了计算机科学领域中的高级算法，并且提供了针对NJU（南京大学）在线评测系统onlineJudge的解答，包括Java和Python两种编程语言的实现。...
学习stopwatch
weixin_44007876的博客
12-07 1360
处理过程（学习stopwatch） 虽然debug可以查看到每一步代码执行时发生的变化，但是不能清楚的看到每一步执行的时间，这个时候Stopwatch就派上用场了。 什么是stopwatch？ Stopwatch是Guava(Google开源java库)中推出的计时器类，可以用于方便的检测两个代码直接执行的速度 Stopwatch简单用法 //引入Guava包guava-19.0.jar impo...
Stopwatch 例子性能测试- 测试代码执行的时间
weixin_34221332的博客
09-29 561
2019独角兽企业重金招聘Python工程师标准>>> ...
TimeUnit.SECONDS与TimeUnit.MILLISECONDS区别
热门推荐
nicknailo博客
03-23 7万+
TimeUnit.SECONDS（5）线程等待五秒 TimeUnit.MILLISECONDS(5000)线程等待五秒. 两者的时间单位不一样。 内部都是Thread.sleep实现。
[自用，更新自day5]瑞吉外卖代码及笔记
最新发布
lapiii的博客
11-01 616
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
10-29 1364
项目功能：商品分类,商品信息,用户。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 841
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
SpringSession源码分析
lkr_lkr的博客
11-01 210
默认对常规Session的理解和使用，如何使用Set-Cookie。
函数式接口与回调函数实践
m0_37635053的博客
10-29 405
函数式接口与回调函数
福特-福克森算法实现最大流
"本文主要介绍了最大流算法，特别是沿增广路径增广的策略，这是福特-福克森算法的核心思想。" 在网络流问题中，我们的目标是在一个带有容量限制的有向图（网络流图）中，找到从源点S到汇点T的最大流量。这个过程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值