限流算法以及实现,java限流实现

　　00-1010为什么要限制电流？限流算法计数器限流漏桶限流令牌桶限流？

　　00-1010在保证可用性的情况下尽可能增加进入人数。剩下的人都在排队，或者回一个友好的提示，保证系统中用户的正常使用，防止系统雪崩。

　　00-1010限流算法很多，常见的有三种，分别是计数器算法、漏桶算法和令牌桶算法。

　　(1)计数器：

　　在一段时间内，要处理的请求的最大数量是固定的，超过的部分不会被处理。

　　(2)桶泄漏：

　　桶的大小是固定的，处理速度是固定的，但是请求的进入速度是不固定的(紧急情况下请求太多的时候会丢弃太多的请求)。

　　(3)令牌桶：

　　令牌桶的大小是固定的，令牌的生成速度是固定的，但是令牌(即请求)的消耗速度是不固定的(可以应对某些时候请求太多的一些情况)；每个请求将从令牌桶中获取令牌，如果没有令牌，该请求将被丢弃。

　　00-1010在一定的时间间隔内，处理请求的最大数量是固定的，超出部分不会被处理。

　　举个例子，比如我们规定对于接口A，一分钟不能访问超过100次。

　　那么我们可以这样做：

　　一开始我们可以设置一个计数器，每来一个请求，计数器就加1。如果计数器的值大于100，并且请求和第一次请求之间的间隔仍在1分钟以内，则意味着请求太多，访问被拒绝。

　　如果这个请求和第一个请求之间的间隔大于1分钟，并且计数器的值仍然在当前的限制范围内，那么就像重置计数器一样简单粗暴。

　　代码实现：

　　导入Java . util . concurrent . countdownlatch；导入Java . util . concurrent . executorservice；导入Java . util . concurrent . executors；导入Java . util . concurrent . atomic . atomic integer；导入Java . util . concurrent . atomic . atomic long；//计数器电流限制公共类counter limiter {//start time private static long start time=system . current time millis()；//时间间隔1000ms私有静态长间隔=1000；//在每个时间间隔内，限制次数私有静态长限制=3；//累加器私有静态原子长累加器=新原子长()；/** * true表示释放，而请求可能已经通过* false表示限制，阻止请求通过*/public static boolean try acquire(){ longnowtime=system . current time millis()；//判断是否在最后一个时间间隔内if (nowtime开始时间间隔){//如果在最后一个时间间隔内，long count=accumulator . incrementandget()；if (count=limit) {返回true} else {返回false}} else {//如果在最后一个时间间隔内没有同步(counter limiter . class){//防止重复初始化If(now time start time interval){ start time=now time；accumulator . set(0)；} }//再次做出判断long count=accumulator . incrementandget()；if (count=limit) {返回true}否则{

　　 return false; } } } // 测试 public static void main(String[] args) { //线程池，用于多线程模拟测试 ExecutorService pool = Executors.newFixedThreadPool(10); // 被限制的次数 AtomicInteger limited = new AtomicInteger(0); // 线程数 final int threads = 2; // 每条线程的执行轮数 final int turns = 20; // 同步器 CountDownLatch countDownLatch = new CountDownLatch(threads); long start = System.currentTimeMillis(); for (int i = 0; i < threads; i++) { pool.submit(() -> { try { for (int j = 0; j < turns; j++) { boolean flag = tryAcquire(); if (!flag) { // 被限制的次数累积 limited.getAndIncrement(); } Thread.sleep(200); } } catch (Exception e) { e.printStackTrace(); } //等待所有线程结束 countDownLatch.countDown(); }); } try { countDownLatch.await(); } catch (InterruptedException e) { e.printStackTrace(); } float time = (System.currentTimeMillis() - start) / 1000F; //输出统计结果 System.out.println("限制的次数为：" + limited.get() + ",通过的次数为：" + (threads * turns - limited.get())); System.out.println("限制的比例为：" + (float) limited.get() / (float) (threads * turns)); System.out.println("运行的时长为：" + time + "s"); }}计数器限流的不足： 

　　这个算法虽然简单，但是存在临界问题，我们看下图：

　　从上图中我们可以看到，假设有一个恶意用户，他在0:59时，瞬间发送了100个请求，并且1:00又瞬间发送了100个请求，那么其实这个用户在 1秒里面，瞬间发送了200个请求。

　　我们刚才规定的是1分钟最多100个请求（规划的吞吐量），也就是每秒钟最多1.7个请求，用户通过在时间窗口的重置节点处突发请求， 可以瞬间超过我们的速率限制。

　　用户有可能通过算法的这个漏洞，瞬间压垮我们的应用。

漏桶限流

漏桶算法限流的基本原理为：水（对应请求）从进水口进入到漏桶里，漏桶以一定的速度出水（请求放行），当水流入速度过大，桶内的总水量大于桶容量会直接溢出，请求被拒绝。

　　大致的漏桶限流规则如下：

　　（1）进水口（对应客户端请求）以任意速率流入进入漏桶。

　　（2）漏桶的容量是固定的，出水（放行）速率也是固定的。

　　（3）漏桶容量是不变的，如果处理速度太慢，桶内水量会超出了桶的容量，则后面流入的水滴会溢出，表示请求拒绝。

　　⭐漏桶算法其实很简单，可以粗略的认为就是注水漏水过程，往桶中以任意速率流入水，以一定速率流出水，当水超过桶容量（capacity）则丢弃，因为桶容量是不变的，保证了整体的速率。

　　以一定速率流出水，

　　削峰： 有大量流量进入时,会发生溢出,从而限流保护服务可用

　　缓冲： 不至于直接请求到服务器, 缓冲压力

　　代码实现： 

import java.util.concurrent.CountDownLatch;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.atomic.AtomicInteger;import java.util.concurrent.atomic.AtomicLong;//漏斗限流public class LeakBucketLimiter { //桶的大小 private static long capacity = 10; //流出速率,每秒两个 private static long rate = 2; //开始时间 private static long startTime = System.currentTimeMillis(); //桶中剩余的水 private static AtomicLong water = new AtomicLong(); /** * true 代表放行，请求可已通过 * false 代表限制，不让请求通过 */ public synchronized static boolean tryAcquire() { //如果桶的余量问0，直接放行 if (water.get() == 0) { startTime = System.currentTimeMillis(); water.set(1); return true; } //计算从当前时间到开始时间流出的水，和现在桶中剩余的水 //桶中剩余的水 water.set(water.get() - (System.currentTimeMillis() - startTime) / 1000 * rate); //防止出现<0的情况 water.set(Math.max(0, water.get())); //设置新的开始时间 startTime += (System.currentTimeMillis() - startTime) / 1000 * 1000; //如果当前水小于容量，表示可以放行 if (water.get() < capacity) { water.incrementAndGet(); return true; } else { return false; } } // 测试 public static void main(String[] args) { //线程池，用于多线程模拟测试 ExecutorService pool = Executors.newFixedThreadPool(10); // 被限制的次数 AtomicInteger limited = new AtomicInteger(0); // 线程数 final int threads = 2; // 每条线程的执行轮数 final int turns = 20; // 同步器 CountDownLatch countDownLatch = new CountDownLatch(threads); long start = System.currentTimeMillis(); for (int i = 0; i < threads; i++) { pool.submit(() -> { try { for (int j = 0; j < turns; j++) { boolean flag = tryAcquire(); if (!flag) { // 被限制的次数累积 limited.getAndIncrement(); } Thread.sleep(200); } } catch (Exception e) { e.printStackTrace(); } //等待所有线程结束 countDownLatch.countDown(); }); } try { countDownLatch.await(); } catch (InterruptedException e) { e.printStackTrace(); } float time = (System.currentTimeMillis() - start) / 1000F; //输出统计结果 System.out.println("限制的次数为：" + limited.get() + ",通过的次数为：" + (threads * turns - limited.get())); System.out.println("限制的比例为：" + (float) limited.get() / (float) (threads * turns)); System.out.println("运行的时长为：" + time + "s"); }}

漏桶的不足： 

　　漏桶的出水速度固定，也就是请求放行速度是固定的。

　　漏桶出口的速度固定，不能灵活的应对后端能力提升。比如，通过动态扩容，后端流量从1000QPS提升到1WQPS，漏桶没有办法。

令牌桶限流

令牌桶算法中新请求到来时会从桶里拿走一个令牌，如果桶内没有令牌可拿，就拒绝服务。 当然，令牌的数量也是有上限的。令牌的数量与时间和发放速率强相关，时间流逝的时间越长，会不断往桶里加入越多的令牌，如果令牌发放的速度比申请速度快，令牌桶会放满令牌，直到令牌占满整个令牌桶。

　　令牌桶限流大致的规则如下：

　　（1）进水口按照某个速度，向桶中放入令牌。

　　（2）令牌的容量是固定的，但是放行的速度不是固定的，只要桶中还有剩余令牌，一旦请求过来就能申请成功，然后放行。

　　（3）如果令牌的发放速度，慢于请求到来速度，桶内就无牌可领，请求就会被拒绝。

　　总之，令牌的发送速率可以设置，从而可以对突发的出口流量进行有效的应对。

　　代码实现： 

import java.util.concurrent.CountDownLatch;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.atomic.AtomicInteger;import java.util.concurrent.atomic.AtomicLong;//令牌桶public class TokenBucketLimiter { //桶的容量 private static long capacity = 10; //放入令牌的速率,每秒2个 private static long rate = 2; //上次放置令牌的时间 private static long lastTime = System.currentTimeMillis(); //桶中令牌的余量 private static AtomicLong tokenNum = new AtomicLong(); /** * true 代表放行，请求可已通过 * false 代表限制，不让请求通过 */ public synchronized static boolean tryAcquire() { //更新桶中剩余令牌的数量 long now = System.currentTimeMillis(); tokenNum.addAndGet((now - lastTime) / 1000 * rate); tokenNum.set(Math.min(capacity, tokenNum.get())); //更新时间 lastTime += (now - lastTime) / 1000 * 1000; //桶中还有令牌就放行 if (tokenNum.get() > 0) { tokenNum.decrementAndGet(); return true; } else { return false; } } //测试 public static void main(String[] args) { //线程池，用于多线程模拟测试 ExecutorService pool = Executors.newFixedThreadPool(10); // 被限制的次数 AtomicInteger limited = new AtomicInteger(0); // 线程数 final int threads = 2; // 每条线程的执行轮数 final int turns = 20; // 同步器 CountDownLatch countDownLatch = new CountDownLatch(threads); long start = System.currentTimeMillis(); for (int i = 0; i < threads; i++) { pool.submit(() -> { try { for (int j = 0; j < turns; j++) { boolean flag = tryAcquire(); if (!flag) { // 被限制的次数累积 limited.getAndIncrement(); } Thread.sleep(200); } } catch (Exception e) { e.printStackTrace(); } //等待所有线程结束 countDownLatch.countDown(); }); } try { countDownLatch.await(); } catch (InterruptedException e) { e.printStackTrace(); } float time = (System.currentTimeMillis() - start) / 1000F; //输出统计结果 System.out.println("限制的次数为：" + limited.get() + ",通过的次数为：" + (threads * turns - limited.get())); System.out.println("限制的比例为：" + (float) limited.get() / (float) (threads * turns)); System.out.println("运行的时长为：" + time + "s"); }}

令牌桶的好处： 

　　令牌桶的好处之一就是可以方便地应对 突发出口流量（后端能力的提升）。

　　比如，可以改变令牌的发放速度，算法能按照新的发送速率调大令牌的发放数量，使得出口突发流量能被处理。

　　到此这篇关于Java 常见的限流算法详细分析并实现的文章就介绍到这了,更多相关Java 限流算法内容请搜索盛行IT以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。