精华内容
下载资源
问答
  • Java限流算法 的四种实现

    千次阅读 2018-06-15 17:09:00
    限流四种实现方式: https://github.com/ZhuBaker/rate-limiter 企业级限流+熔断: https://github.com/ZhuBaker/distributed-current-limiter 转载于:...

    限流四种实现方式:

    https://github.com/ZhuBaker/rate-limiter

    企业级限流+熔断:

    https://github.com/ZhuBaker/distributed-current-limiter

    转载于:https://my.oschina.net/LucasZhu/blog/1831055

    展开全文
  • java限流算法

    2019-09-23 10:55:06
    ** Java限流算法** 概要 在大数据量高并发访问时,经常会出现服务或接口面对暴涨的请求而不可用的情况,甚至引发连锁反映导致整个系统崩溃。此时你需要使用的技术手段之一就是限流,当请求达到一定的并发数或速率,...
    						        **  Java限流算法**
    

    概要

    在大数据量高并发访问时,经常会出现服务或接口面对暴涨的请求而不可用的情况,甚至引发连锁反映导致整个系统崩溃。此时你需要使用的技术手段之一就是限流,当请求达到一定的并发数或速率,就进行等待、排队、降级、拒绝服务等。

    在开发高并发系统时,有三把利器用来保护系统:缓存、降级和限流:

    • 缓存:缓存的目的是提升系统访问速度和增大系统处理容量

    • 降级:降级是当服务出现问题或者影响到核心流程时,需要暂时屏蔽掉,待高峰或者问题解决后再打开(12306)

    • 限流:限流的目的是通过对并发访问/请求进行限速,或者对一个时间窗口内的请求进行限速来保护系统,一旦达到限制速率则可以拒绝服务、排队或等待、降级等处理

    常见的限流算法有:令牌桶、漏桶。(两桶)。计数器算法。

    计数器法

    计数器是最简单的限流算法,思路是维护一个单位时间内的计数器 Counter,如判断单位时间已经过去,则将计数器归零。

    1. 可以在程序中设置一个变量 count,当过来一个请求我就将这个数 +1,同时记录请求时间。

    2. 当下一个请求来的时候判断 count 的计数值是否超过设定的频次,以及当前请求的时间和第一次请求时间是否在 1 分钟内

    3. 如果在 1 分钟内并且超过设定的频次则证明请求过多,后面的请求就拒绝掉。

    4. 如果该请求与第一个请求的间隔时间大于 1 分钟,且 count 值还在限流范围内,就重置 count。

      这种方法虽然简单,但也有个大问题就是没有很好的处理单位时间的边界。
      假设有个用户在第 59 秒的最后几毫秒瞬间发送 200 个请求,当 59 秒结束后 Counter 清零了,他在下一秒的时候又发送 200 个请求。那么在 1 秒钟内这个用户发送了 2 倍的请求,如下图:
      在这里插入图片描述
      这种方式的缺点在于它没有更细粒度的划分临界点,如果我们可以把这个时间窗口划分成 6 份,每一份代表 10 秒,当然你可以将它划分的更细。

    漏桶算法

    首先,我们有一个固定容量的桶,有水流进来,也有水流出去。对于流进来的水来说,我们无法预计一共有多少水会流进来,也无法预计水流的速度。但是对于流出去的水来说,这个桶可以固定水流出的速率。而且,当桶满了之后,多余的水将会溢出。

    在这里插入图片描述

    漏桶算法限制了请求的速度。当使用了漏桶算法,我们可以保证接口会以一个常速速率来处理请求。

    令牌桶算法

    首先,我们有一个固定容量的桶,桶里存放着令牌(token)。桶一开始是空的,token以 一个固定的速率r往桶里填充,直到达到桶的容量,多余的令牌将会被丢弃。每当一个请求过来时,就会尝试从桶里移除一个令牌,如果没有令牌的话,请求无法通过。

    在这里插入图片描述

    漏桶算法和令牌桶算法最明显的区别是令牌桶算法允许流量一定程度的突发。因为默认的令牌桶算法,取走token是不需要耗费时间的,也就是说,假设桶内有100个token时,那么可以瞬间允许100个请求通过。

    令牌桶算法由于实现简单,且允许某些流量的突发,对用户友好,所以被业界采用地较多。当然我们需要具体情况具体分析,只有最合适的算法,没有最优的算法。

    展开全文
  • 0. 前言常见的限流算法有:令牌桶、漏桶。计数器也可以进行粗暴限流实现。1. 算法介绍1.1 令牌桶算法令牌桶算法是一个存放固定容量令牌的桶,按照固定速率往桶里添加令牌。令牌桶算法的描述如下:假设限制2r/s,则...

    0. 前言

    常见的限流算法有:令牌桶、漏桶。计数器也可以进行粗暴限流实现。

    1. 算法介绍

    1.1 令牌桶算法

    令牌桶算法是一个存放固定容量令牌的桶,按照固定速率往桶里添加令牌。令牌桶算法的描述如下:

    假设限制2r/s,则按照500毫秒的固定速率往桶中添加令牌;

    桶中最多存放b个令牌,当桶满时,新添加的令牌被丢弃或拒绝;

    当一个n个字节大小的数据包到达,将从桶中删除n个令牌,接着数据包被发送到网络上;

    如果桶中的令牌不足n个,则不会删除令牌,且该数据包将被限流(要么丢弃,要么缓冲区等待)。

    cbe4f1cf2e8d332f288e469044f4f015.png

    1.2 漏桶算法

    漏桶作为计量工具(The Leaky Bucket Algorithm as a Meter)时,可以用于流量整形(Traffic Shaping)和流量控制(TrafficPolicing),漏桶算法的描述如下:

    一个固定容量的漏桶,按照常量固定速率流出水滴;

    如果桶是空的,则不需流出水滴;

    可以以任意速率流入水滴到漏桶;

    如果流入水滴超出了桶的容量,则流入的水滴溢出了(被丢弃),而漏桶容量是不变的。

    dcc449bd8289bbdb9a4a78654a44c3c8.png

    1.3 总结

    令牌桶和漏桶对比:

    令牌桶是按照固定速率往桶中添加令牌,请求是否被处理需要看桶中令牌是否足够,当令牌数减为零时则拒绝新的请求;

    漏桶则是按照常量固定速率流出请求,流入请求速率任意,当流入的请求数累积到漏桶容量时,则新流入的请求被拒绝;

    令牌桶限制的是平均流入速率(允许突发请求,只要有令牌就可以处理,支持一次拿3个令牌,4个令牌),并允许一定程度突发流量;

    漏桶限制的是常量流出速率(即流出速率是一个固定常量值,比如都是1的速率流出,而不能一次是1,下次又是2),从而平滑突发流入速率;

    令牌桶允许一定程度的突发,而漏桶主要目的是平滑流入速率;

    两个算法实现可以一样,但是方向是相反的,对于相同的参数得到的限流效果是一样的。

    另外有时候我们还使用计数器来进行限流,主要用来限制总并发数,比如数据库连接池、线程池、秒杀的并发数;只要全局总请求数或者一定时间段的总请求数设定的阀值则进行限流,是简单粗暴的总数量限流,而不是平均速率限流。

    2. 算法实现

    《java接口限流小结》中的限流方式都不能很好地应对突发请求,即瞬间请求可能都被允许从而导致一些问题;因此在一些场景中需要对突发请求进行整形,整形为平均速率请求处理(比如5r/s,则每隔200毫秒处理一个请求,平滑了速率)。这个时候有两种算法满足我们的场景:令牌桶和漏桶算法。Guava框架提供了令牌桶算法实现,可直接拿来使用。

    Guava RateLimiter提供了令牌桶算法实现:平滑突发限流(SmoothBursty)和平滑预热限流(SmoothWarmingUp)实现。

    2.1 SmoothBursty

    RateLimiter limiter = RateLimiter.create(5);

    System.out.println(limiter.acquire());

    System.out.println(limiter.acquire());

    System.out.println(limiter.acquire());

    System.out.println(limiter.acquire());

    System.out.println(limiter.acquire());

    System.out.println(limiter.acquire());

    将得到类似如下的输出:

    0.0

    0.198903

    0.195463

    0.19712

    0.199252

    0.196105

    1、RateLimiter.create(5) 表示桶容量为5且每秒新增5个令牌,即每隔200毫秒新增一个令牌;

    2、limiter.acquire()表示消费一个令牌,如果当前桶中有足够令牌则成功(返回值为0),如果桶中没有令牌则暂停一段时间,比如发令牌间隔是200毫秒,则等待200毫秒后再去消费令牌(如上测试用例返回的为0.198239,差不多等待了200毫秒桶中才有令牌可用),这种实现将突发请求速率平均为了固定请求速率。

    再看一个突发示例:

    RateLimiter limiter = RateLimiter.create(5);

    System.out.println(limiter.acquire(5));

    System.out.println(limiter.acquire(1));

    System.out.println(limiter.acquire(1));

    将得到类似如下的输出:

    0.0

    0.998729

    0.19379

    limiter.acquire(5)表示桶的容量为5且每秒新增5个令牌,令牌桶算法允许一定程度的突发,所以可以一次性消费5个令牌,但接下来的limiter.acquire(1)将等待差不多1秒桶中才能有令牌,且接下来的请求也整形为固定速率了。

    RateLimiter limiter = RateLimiter.create(5);

    System.out.println(limiter.acquire(10));

    System.out.println(limiter.acquire(1));

    System.out.println(limiter.acquire(1));

    将得到类似如下的输出:

    0.0

    1.998922

    0.19615

    同上边的例子类似,第一秒突发了10个请求,令牌桶算法也允许了这种突发(允许消费未来的令牌),但接下来的limiter.acquire(1)将等待差不多2秒桶中才能有令牌,且接下来的请求也整形为固定速率了。

    接下来再看一个突发的例子:

    RateLimiter limiter = RateLimiter.create(2);

    System.out.println(limiter.acquire());

    Thread.sleep(2000L);

    System.out.println(limiter.acquire());

    System.out.println(limiter.acquire());

    System.out.println(limiter.acquire());

    System.out.println(limiter.acquire());

    System.out.println(limiter.acquire());

    接下来再看一个突发的例子:

    0.0

    0.0

    0.0

    0.0

    0.499738

    0.496078

    1、创建了一个桶容量为2且每秒新增2个令牌;

    2、首先调用limiter.acquire()消费一个令牌,此时令牌桶可以满足(返回值为0);

    3、然后线程暂停2秒,接下来的两个limiter.acquire()都能消费到令牌,第三个limiter.acquire()也同样消费到了令牌,到第四个时就需要等待500毫秒了。

    此处可以看到我们设置的桶容量为2(即允许的突发量),这是因为SmoothBursty中有一个参数:最大突发秒数(maxBurstSeconds)默认值是1s,突发量/桶容量=速率*maxBurstSeconds,所以本示例桶容量/突发量为2,例子中前两个是消费了之前积攒的突发量,而第三个开始就是正常计算的了。令牌桶算法允许将一段时间内没有消费的令牌暂存到令牌桶中,留待未来使用,并允许未来请求的这种突发。

    SmoothBursty通过平均速率和最后一次新增令牌的时间计算出下次新增令牌的时间的,另外需要一个桶暂存一段时间内没有使用的令牌(即可以突发的令牌数)。另外RateLimiter还提供了tryAcquire方法来进行无阻塞或可超时的令牌消费。

    因为SmoothBursty允许一定程度的突发,会有人担心如果允许这种突发,假设突然间来了很大的流量,那么系统很可能扛不住这种突发。因此需要一种平滑速率的限流工具,从而系统冷启动后慢慢的趋于平均固定速率(即刚开始速率小一些,然后慢慢趋于我们设置的固定速率)。Guava也提供了SmoothWarmingUp来实现这种需求,其可以认为是漏桶算法,但是在某些特殊场景又不太一样。

    2.2 SmoothWarmingUp

    SmoothWarmingUp创建方式:RateLimiter.create(doublepermitsPerSecond, long warmupPeriod, TimeUnit unit)

    permitsPerSecond表示每秒新增的令牌数,warmupPeriod表示在从冷启动速率过渡到平均速率的时间间隔。

    示例如下:

    RateLimiter limiter = RateLimiter.create(5, 1000, TimeUnit.MILLISECONDS);

    for(int i = 1; i < 5;i++) {

    System.out.println(limiter.acquire());

    }

    Thread.sleep(1000L);

    for(int i = 1; i < 5;i++) {

    System.out.println(limiter.acquire());

    }

    将得到类似如下的输出:

    0.0

    0.518916

    0.356743

    0.219183

    0.0

    0.519927

    0.354751

    0.214637

    速率是梯形上升速率的,也就是说冷启动时会以一个比较大的速率慢慢到平均速率;然后趋于平均速率(梯形下降到平均速率)。可以通过调节warmupPeriod参数实现一开始就是平滑固定速率。

    到此应用级限流的一些方法就介绍完了。假设将应用部署到多台机器,应用级限流方式只是单应用内的请求限流,不能进行全局限流。因此我们需要分布式限流和接入层限流来解决这个问题。

    展开全文
  • 在网上搜滑动时间窗口限流算法,大多都太复杂了,本人实现了个简单的,先上代码:package cn.dijia478.util;import java.time.LocalTime;import java.util.LinkedList;import java.util.List;import java.util.Map;...

    在网上搜滑动时间窗口限流算法,大多都太复杂了,本人实现了个简单的,先上代码:

    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.util.concurrent.ConcurrentHashMap;

    /**

    * 滑动时间窗口限流工具

    * 本限流工具只适用于单机版,如果想要做全局限流,可以按本程序的思想,用redis的List结构去实现

    *

    * @author dijia478

    * @date 2020-10-13 10:53

    */

    public class SlideWindow {

    /** 队列id和队列的映射关系,队列里面存储的是每一次通过时候的时间戳,这样可以使得程序里有多个限流队列 */

    private volatile static Map> MAP = new ConcurrentHashMap<>();

    private SlideWindow() {}

    public static void main(String[] args) throws InterruptedException {

    while (true) {

    // 任意10秒内,只允许2次通过

    System.out.println(LocalTime.now().toString() + SlideWindow.isGo("ListId", 2, 10000L));

    // 睡眠0-10秒

    Thread.sleep(1000 * new Random().nextInt(10));

    }

    }

    /**

    * 滑动时间窗口限流算法

    * 在指定时间窗口,指定限制次数内,是否允许通过

    *

    * @param listId 队列id

    * @param count 限制次数

    * @param timeWindow 时间窗口大小

    * @return 是否允许通过

    */

    public static synchronized boolean isGo(String listId, int count, long timeWindow) {

    // 获取当前时间

    long nowTime = System.currentTimeMillis();

    // 根据队列id,取出对应的限流队列,若没有则创建

    List list = MAP.computeIfAbsent(listId, k -> new LinkedList<>());

    // 如果队列还没满,则允许通过,并添加当前时间戳到队列开始位置

    if (list.size() < count) {

    list.add(0, nowTime);

    return true;

    }

    // 队列已满(达到限制次数),则获取队列中最早添加的时间戳

    Long farTime = list.get(count - 1);

    // 用当前时间戳 减去 最早添加的时间戳

    if (nowTime - farTime <= timeWindow) {

    // 若结果小于等于timeWindow,则说明在timeWindow内,通过的次数大于count

    // 不允许通过

    return false;

    } else {

    // 若结果大于timeWindow,则说明在timeWindow内,通过的次数小于等于count

    // 允许通过,并删除最早添加的时间戳,将当前时间添加到队列开始位置

    list.remove(count - 1);

    list.add(0, nowTime);

    return true;

    }

    }

    }

    运行可以看到,任意10秒内,通过的次数不超过2次。或者按照实现原理来说,任意通过2次内的时间差,都不超过10秒:

    42269a01160a561bc36dc119493c2c34.png

    这里画图做说明,为什么这样可以做到滑动窗口限流,假设10秒内允许通过5次

    1.这条线就是队列list,当第一个事件进来,队列大小是0,时间是第1秒:

    f37a0c44a948b7e429108acb2ab3d909.png

    2.因为size=0,小于5,都没有到限制的次数,完全不用考虑时间窗口,直接把这次事件的时间戳放到0的位置:

    ae678709402f5fef115d0a7d58d86a77.png

    3.第2.8秒的时候,第二个事件来了。因为此时size=1,还是小于5,把这次事件的时间戳放到0的位置,原来第1秒来的事件时间戳会往后移动一格:

    71e085816357d696d49adcce67b498f7.png

    4.陆续的又来了3个事件,队列大小变成了5,先来的时间戳依次向后移动。此时,第6个事件来了,时间是第8秒:

    8af7e03a9c58a786d826afa0dd5544d6.png

    5.因为size=5,不小于5,此时已经达到限制次数,以后都需要考虑时间窗口了。所以取出位置4的时间(离现在最远的时间),和第6个事件的时间戳做比较:

    be539d2b89899d0f8ba2f8224608f00f.png

    6.得到的差是7秒,小于时间窗口10秒,说明在10秒内,来的事件个数大于5了,所以本次不允许通过:

    de305c6b121eff9819d9c6e40a782d53.png

    7.接下来即便来上100个事件,只要时间差小于等于10秒,都同上,拒绝通过:

    35d93306ca89d4159fda8b67bab2d219.png

    8.第11.1秒,第101次事件过来了。因为size=5,不小于5,所以取出位置4的时间(离现在最远的时间),和第101个事件的时间戳做比较:

    d76cd6876174b3a84be12e6ba27e009c.png

    9.得到的差是10.1秒,大于时间窗口10秒,说明在10秒内,来的事件个数小于等于5了,所以本次允许通过:

    111c4079fa005cfc67d2a76874cd2f60.png

    10.删除位置4的时间(离现在最远的时间),把这次事件的时间戳放到0的位置,后面的时间戳依次向后移动:

    1eb54e1bf605e1b5fda70c58dc1bdced.png

    往后再来其他事件,就是重复4-10的步骤,即可实现,在任意滑动时间窗口内,限制通过的次数

    其本质思想是转换概念,将原本问题的确定时间大小,进行次数限制。转换成确定次数大小,进行时间限制。

    到此这篇关于Java 实现滑动时间窗口限流算法的代码的文章就介绍到这了,更多相关Java滑动时间窗口限流算法内容请搜索云海天教程以前的文章或继续浏览下面的相关文章希望大家以后多多支持云海天教程!

    原文链接:https://www.cnblogs.com/javastack/archive/2020/11/26/14041112.html

    展开全文
  • 在网上搜滑动时间窗口限流算法,大多都太复杂了,本人实现了个简单的,先上代码:packagecn.dijia478.util;importjava.time.LocalTime;importjava.util.LinkedList;importjava.util.List;importjava.util.Map;import...
  • 限流算法之令牌桶法(Java实现)前面2篇说过限速算法,可以参考以下:限流算法之计数器算法(Java实现)限流算法之滑动窗口法(Java实现)令牌桶算计介绍今天简单解释另一种令牌桶法,系统会以一定的速率往桶里添加令牌,...
  • 原标题:Java 实现滑动时间窗口限流算法,你见过吗?作者:dijia478在网上搜滑动时间窗口限流算法,大多都太复杂了,本人实现了个简单的,先上代码:package cn.dijia478.util;import java.time.LocalTime;import ...
  • Java接口限流算法

    千次阅读 2018-07-20 08:39:55
    常见的限流算法有:令牌桶、漏桶。计数器也可以进行粗暴限流实现。 1. 算法介绍 1.1 令牌桶算法 令牌桶算法是一个存放固定容量令牌的桶,按照固定速率往桶里添加令牌。令牌桶算法的描述如下: * ...
  •   在Java开发过程中,经常用到的限流算法有两种,一种是令牌桶算法,一种是漏斗桶算法,那么下面就来分别看看两种算法的Java实现方式。 文章目录限流算法之漏桶算法漏桶的实现限流算法之令牌桶法简单的令牌桶算法...
  • 简单介绍4种非常好理解并且容易实现的限流算法!固定窗口计数器算法规定我们单位时间处理的请求数量。比如我们规定我们的一个接口一分钟只能访问10次的话。使用固定窗口计数器算法的话可以这样实现:给定一个变量...
  • 在网上搜滑动时间窗口限流算法,大多都太复杂了,本人实现了个简单的,先上代码:packagecn.dijia478.util;importjava.time.LocalTime;importjava.util.LinkedList;importjava.util.List;importjava.util.Map;import...
  • 在网上搜滑动时间窗口限流算法,大多都太复杂了,本人实现了个简单的,先上代码:package cn.dijia478.util;import java.time.LocalTime;import java.util.LinkedList;import java.util.List;import java.util.Map;...
  • 限流限流问题可以追溯到网络通信中的流量整形(Traffic Shaping)和流量控制(Traffic Policing)。下面一起小窥一下有哪些精彩的算法。简单窗口流量曲线优点:实现简单缺点:精确度不够,临界情况下会qps会超出实际...
  • 上文简单介绍过限流中的计数器法,详情参考:限流算法之计数器算法(Java实现)计数器法有个缺点就是临界问题。举个例子,我们限制每分钟调用接口不能超过1000次,用计数器法实现时,如果恶意用户在01:59秒一秒内发送...
  • 常用的限流算法有:滑动窗口、漏斗以及令牌桶。得益于redis的数据结构特点,redis实现滑动窗口限流和漏斗限流的非常的便捷。滑动窗口限流的原理和实现以xx论坛限制用户行为为例子,比如一秒内进行...
  • 今天来说说限流的相关内容,包括常见的限流算法、单机限流场景、分布式限流场景以及一些常见限流组件。当然在介绍限流算法和具体场景之前我们先得明确什么是限流,为什么要限流?。任何技术都要搞清它的来源,技术的...
  • 常见限流算法常用的限流算法有:令牌桶,漏桶、滑动窗口算法。 2.市面上常用实现限流框架 有Nginx+Lua、Guava、Hystrix等 令牌桶算法原理 以规定的速率往令牌桶中存入Token,用户请求必须获取到令牌中的Token才...
  • 前言在解决系统面对高并发的场景下,有三把主要利器,分别是缓存,降级,限流。缓存是通过提升系统访问速度和增大系统处理能力,能大幅度缓解高并发的冲击。降级是当服务出现问题或者影响到核心流程时的性能时,需要...
  • 基于令牌桶算法Java限流实现。 项目需要使用限流措施,查阅后主要使用令牌桶算法实现,为了更灵活的实现限流,就自己实现了一个简单的基于令牌桶算法的限流实现。
  • Java实现漏斗限流算法

    千次阅读 2018-09-28 17:38:09
    最近在学习老钱的《Redis深度历险:核心原理与应用实践》,其中讲到了漏斗限流,在Redis中可以使用 Redis-Cell 模块来做基于Redis的限流方案。在讲解原理的时候,老钱给出了 Python 和 Java 版的实现,看完之后发现...
  • Java学习五分钟系列,目的是为让大家在短时间内搞清楚一项技术的概念、优缺点和适用场景,想要深入的...说到限流,那就要提到限流算法,常用的有【漏桶算法】和【令牌桶算法】两种限流算法。漏桶算法漏桶算法,顾名...
  • java实现 限流算法 漏斗模型

    千次阅读 2019-03-19 17:17:14
    package com.example.redis.漏斗限流; /** * @Auther: liuyujie * @Date: 2019/3/4 12:48 * @Description: */ public class Funnel { int capacity;//漏斗容量 double leakingRate;//漏水速度 int leftQuota...
  • 1 计数器算法(单机限流) 具体的实现可以是这样的:对于每次服务调用,可以通过AtomicLong#incrementAndGet()方法来给计数器加1并返回最新值,通过这个最新值和阈值进行比较。 这种实现方式,相信大家都知道有一个...
  • 引言 本篇内容根据《spring cloud alibaba 微服务原理与实战》中内容摘取,希望和大家分享限流的思想,本篇不涉及代码层面的实现。 限流的目的 目的:通过限制并发访问...限流的四种算法 1、计数器算法 计数器算法
  • 项目需要使用限流措施,查阅后主要使用令牌桶算法实现,为了更灵活的实现限流,就自己实现了一个简单的基于令牌桶算法限流实现。令牌桶算法描述令牌桶这种控制机制基于令牌桶中是否存在令牌来指示什么时候可以发送...
  • 限流算法java实现令牌桶算法

    千次阅读 2019-11-18 19:45:16
    代码逻辑:线程池每0.5s发送随机数量的请求,每次请求计算当前的令牌数量,请求令牌数量超出当前令牌数量,则产生限流。 @Slf4j public class TokensLimiter { private ScheduledExecutorServ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 562
精华内容 224
关键字:

java限流算法

java 订阅