怎样注册微信小商店,seo优化方案模板,互联网行业网站模板,成都装饰公司前十强是哪几个0、基础知识
1000毫秒内#xff0c;允许2个请求#xff0c;其他请求全部拒绝。
不拒绝就可能往db打请求#xff0c;把db干爆~
interval 1000
rate 2#xff1b; 一、固定窗口限流
固定窗口限流算法#xff08;Fixed Window Rate Limiting Algorithm#xff09;是…0、基础知识
1000毫秒内允许2个请求其他请求全部拒绝。
不拒绝就可能往db打请求把db干爆~
interval 1000
rate 2 一、固定窗口限流
固定窗口限流算法Fixed Window Rate Limiting Algorithm是一种最简单的限流算法其原理是在固定时间窗口(单位时间)内限制请求的数量。通俗点说主要通过一个支持原子操作的计数器来累计 1 秒内的请求次数当 1 秒内计数达到限流阈值时触发拒绝策略。每过 1 秒计数器重置为 0 开始重新计数。 /*** 固定窗口限流算法* 比如1000ms 允许通过10个请求* author jeb_lin* 14:14 2023/11/19*/
public class FixWindowRateLimiter {private long interval; // 窗口的时间间隔private long rate; // 限制的调用次数private long lastTimeStamp; // 上次请求来的时间戳private AtomicLong counter; // 计数器public FixWindowRateLimiter(long interval,long rate){this.interval interval;this.rate rate;this.lastTimeStamp System.currentTimeMillis();this.counter new AtomicLong(0);}public static void main(String[] args) {// 比如1000ms 允许通过10个请求FixWindowRateLimiter limiter new FixWindowRateLimiter(1000,2);for (int i 0; i 4; i) {if(limiter.allow()){System.out.println(i - ok );} else {System.out.println(i - no);}}}private boolean allow() {long now System.currentTimeMillis();if(now - lastTimeStamp interval){counter.set(0L);lastTimeStamp now;}if(counter.get() rate){return false;} else {counter.incrementAndGet();return true;}}
}
输出:
0 - ok
1 - ok
2 - no
3 - no
优点
简单易懂
缺陷
存在临界问题
本来就允许1秒内进来2个请求这时候进来了4个 /*** 测试不正常的情况*/private static void testUnNormal() throws Exception{// 比如1000ms 允许通过10个请求FixWindowRateLimiter limiter new FixWindowRateLimiter(1000,2);Thread.sleep(500);for (int i 0; i 4; i) {if(limiter.allow()){System.out.println(i - ok );} else {System.out.println(i - no);}Thread.sleep(250);}}
输出
0 - ok
1 - ok
2 - ok
3 - ok 二、滑动窗口限流
滑动窗口限流算法是一种常用的限流算法它将单位时间周期分为n个小周期分别记录每个小周期内接口的访问次数并且根据时间滑动删除过期的小周期。比如上图的示例中每 500ms 滑动一次窗口就可以避免这种临界问题可以发现窗口滑动的间隔越短时间窗口的临界突变问题发生的概率也就越小不过只要有时间窗口的存在还是有可能发生时间窗口的临界突变问题。 类似于微积分假如我切成1000个窗口每1ms一个计数器
/*** 滑动窗口限流算法* 比如1000ms 允许通过 2 个请求** author jeb_lin* 14:14 2023/11/19*/
public class SlidingWindowRateLimiter {private long interval; // 窗口的时间间隔private long maxRequest; // 限制的调用次数private MapLong, AtomicLong millToCount null; // 假如1秒切成1000个窗口也就是1毫秒一个计数器private LinkedListLong timeStampList null; // 出现请求的那个时间戳需要记录下来用于后期的删除private AtomicLong counter; // 计数器public SlidingWindowRateLimiter(long interval, long maxRequest) {this.interval interval;this.maxRequest maxRequest;this.millToCount new HashMap();this.timeStampList new LinkedList();this.counter new AtomicLong(0);}public static void main(String[] args) throws Exception {testNormal();}/*** 测试正常的情况*/private static void testNormal() {// 比如1000ms 允许通过10个请求SlidingWindowRateLimiter limiter new SlidingWindowRateLimiter(1000, 2);for (int i 0; i 10; i) {if (limiter.allow()) {System.out.println(i - ok );} else {System.out.println(i - no);}}}private boolean allow() {long now System.currentTimeMillis();// 剔除掉过期的窗口比如现在是1001ms那么1ms的窗口就需要剔除掉while (!timeStampList.isEmpty() now - interval timeStampList.getFirst()) {long timeStamp timeStampList.poll();for (int i 0; i millToCount.getOrDefault(timeStamp,new AtomicLong(0)).get(); i) {counter.decrementAndGet();}millToCount.remove(timeStamp);}if (counter.get() maxRequest) {return false;} else {timeStampList.add(now); // 当前出现成功请求那么串上listAtomicLong timeStampCounter millToCount.getOrDefault(now, new AtomicLong(0L));timeStampCounter.incrementAndGet();millToCount.put(now, timeStampCounter);counter.incrementAndGet();return true;}}
}
优点
简单易懂精度高通过调整时间窗口的大小来实现不同的限流效果
缺陷
依旧存在临界问题不可能无限小占用更多内存空间 三、漏桶算法固定消费速率
漏桶限流算法Leaky Bucket Algorithm拥有更平滑的流量控制能力。其中漏桶是一个形象的比喻这里可以用生产者消费者模式进行说明请求是一个生产者每一个请求都如一滴水请求到来后放到一个队列漏桶中而桶底有一个孔不断的漏出水滴就如消费者不断的在消费队列中的内容消费的速率漏出的速度等于限流阈值。即假如 QPS 为 2则每 1s / 2 500ms 消费一次。漏桶的桶有大小就如队列的容量当请求堆积超过指定容量时会触发拒绝策略。
类似于Kafka的消费者在不调整配置的情况下消费速度是固定的多余的请求会积压如果超过你kafka配置的topic最大磁盘容量那么会丢消息。topic是一个目录topic下N个partition目录假如你每个partition配置了1G的容量那么超过这个这个容量就会删除partition下的segement文件 xxx.index,xxx.log /*** 漏桶算法* 比如 1秒只能消费2个请求** author jeb_lin* 15:55 2023/11/19*/
public class LeakyBucketRateLimiter {private int consumerRate; // 消费速度private Long interval; // 时间间隔比如1000msprivate int bucketCapacity; // 桶的容量private AtomicLong water; // 桶里面水滴数量public LeakyBucketRateLimiter(int consumerRate, Long interval, int bucketCapacity) {this.consumerRate consumerRate;this.interval interval;this.bucketCapacity bucketCapacity;this.water new AtomicLong(0);scheduledTask();}// 周期任务比如每1000ms消费2个请求private void scheduledTask() {ScheduledExecutorService service Executors.newScheduledThreadPool(1);service.scheduleAtFixedRate((Runnable) () - {for (int i 0; i consumerRate water.get() 0; i) {this.water.decrementAndGet();}System.out.println(water - this.water.get());}, 0, interval, TimeUnit.MILLISECONDS);}public static void main(String[] args) {// 1000毫秒消费2个请求LeakyBucketRateLimiter limiter new LeakyBucketRateLimiter(2, 1000L, 10);for (int i 0; i 10; i) {if (limiter.allow()) {System.out.println(i - ok);} else {System.out.println(i - no);}}}private boolean allow() {if (bucketCapacity water.get() 1) {return false;} else {water.incrementAndGet();return true;}}
}
输出
0 - ok
1 - ok
2 - no
3 - no
4 - no
5 - no
6 - no
7 - no
8 - no
9 - no
优点
可以控制请求的处理速度避免过载或者过度闲置避免瞬间请求过多导致系统崩溃或者雪崩。可以通过调整桶的大小和漏出速率来满足不同的限流需求这个基本靠手动
缺陷
需要对请求进行缓存会增加服务器的内存消耗。但是面对突发流量的时候漏桶算法还是循规蹈矩地按照固定的速率处理请求。 四、令牌桶算法
令牌桶算法是一种常用的限流算法相对于漏桶算法它可以更好地应对突发流量和解决内存消耗的问题。该算法维护一个固定容量的令牌桶每秒钟会向令牌桶中放入一定数量的令牌。当有请求到来时如果令牌桶中有足够的令牌则请求被允许通过并从令牌桶中消耗一个令牌否则请求被拒绝。 4.2 令牌桶限流代码实现 import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;/*** 令牌桶限流算法* 每 1000ms 生成2个令牌** author jeb_lin* 14:14 2023/11/19*/
public class TokenBucketRateLimiter {private long interval; // 窗口的时间间隔private long rate; // 速率private AtomicLong tokenCounter; // 令牌的数量private final long bucketCapacity; // 桶的大小public TokenBucketRateLimiter(long interval, long rate ,long bucketCapacity) {this.interval interval;this.rate rate;this.tokenCounter new AtomicLong(0);this.bucketCapacity bucketCapacity;scheduledProduceToken();}private void scheduledProduceToken() {ExecutorService executorService Executors.newScheduledThreadPool(1);((ScheduledExecutorService) executorService).scheduleAtFixedRate(new Runnable() {Overridepublic void run() {// 桶里面放不下了if(tokenCounter.get() rate bucketCapacity){System.out.println(bucket is full);return;}long token tokenCounter.addAndGet(rate);System.out.println(token - token);}}, 0, interval, TimeUnit.MILLISECONDS);}public static void main(String[] args) throws Exception {testNormal();}/*** 测试正常的情况*/private static void testNormal() throws Exception{// 比如1000ms 允许通过10个请求TokenBucketRateLimiter limiter new TokenBucketRateLimiter(1000, 2,10);// 模拟瞬时流量5秒前都没请求5秒后瞬时流量上来了Thread.sleep(5000);for (int i 0; i 12; i) {if (limiter.allow()) {System.out.println(i - ok );} else {System.out.println(i - no);}}}private boolean allow() {if(tokenCounter.get() 0){tokenCounter.getAndDecrement();return true;}return false;}
}
输出
token - 2
token - 4
token - 6
token - 8
token - 10
bucket is full
0 - ok
1 - ok
2 - ok
3 - ok
4 - ok
5 - ok
6 - ok
7 - ok
8 - ok
9 - ok
10 - no
11 - no
优点 Guava的RateLimiter限流组件就是基于令牌桶算法实现的。
精度高令牌桶算法可以根据实际情况动态调整生成令牌的速率可以实现较高精度的限流。弹性好令牌桶算法可以处理突发流量可以在短时间内提供更多的处理能力以处理突发流量。
缺陷
实现复杂在短时间内有大量请求到来时可能会导致令牌桶中的令牌被快速消耗完从而限流。这种情况下可以考虑使用漏桶算法。需要削峰填谷学习kafka就用漏桶算法时间精度要求高令牌桶算法需要在固定的时间间隔内生成令牌因此要求时间精度较高如果系统时间不准确可能会导致限流效果不理想。
