限流技术总结

最新推荐文章于 2024-08-09 09:48:48 发布

HG_weikaifang

最新推荐文章于 2024-08-09 09:48:48 发布

阅读量563

点赞数

分类专栏：网站优化

本文链接：https://blog.csdn.net/HG_weikaifang/article/details/88973380

版权

网站优化专栏收录该内容

1 篇文章 0 订阅

订阅专栏

限流技术主要有以下几种

信号量
计数器
滑动窗口
漏桶算法
令牌桶算法
分布式限流

信号量：信号量实际上就是限制系统的并发量，来达到限流的目的。常见的用法是：创建Semaphore，指定permit的数量。在方法开始时，调用Semaphore.acquire()或者Semaphore.tryAcquire()来获取permit，并在方法返回前，调用Semaphore.release()来返还permit。（线程方面）

计数器：

计数器的方案比较简单。比如限制1秒钟内请求数最多为10个，每当进来一个请求，则计数器+1。当计数器达到上限时，则触发限流。时间每经过1秒，则重置计数器。

滑动窗口：

滑动窗口本质上也是一种计数器，只不过它的粒度更细。比如限制qps为1000，设定窗口大小为10，则每个窗口的时间间隔为100ms。每次窗口滑动时，重置的是前1s至900ms之间内的计数，而不是完整的1s。

示例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

public class RateLimiter {
    private LinkedList<Integer> deque = new LinkedList<>();
    private int windowSize;
    private int windowIntervalMilliSeconds;
    private int currentWindowPermits;

    private long updateTimeStamp;
    private int intervalMilliSeconds;
    private int maxPermits;
    private long storedPermits;

    public RateLimiter(int maxPermits, int windowSize) {
        this(maxPermits, 1, windowSize);
    }

    public RateLimiter(int maxPermits, int intervalSeconds, int windowSize) {
        this.maxPermits = maxPermits;
        this.intervalMilliSeconds = intervalSeconds * 1000;
        this.windowSize = windowSize;
        this.windowIntervalMilliSeconds = intervalMilliSeconds / windowSize;
    }

    public synchronized Boolean acquire(int permits) {
        while (true) {
            long now = System.currentTimeMillis();
            if (now < updateTimeStamp + windowIntervalMilliSeconds) {
               if (storedPermits + permits + currentWindowPermits <= maxPermits) {
                    currentWindowPermits += permits;
                    updateTimeStamp = now;
                    return true;
                } else {
                    return false;
                }
            } else {
                updateTimeStamp = now;
                deque.offerLast(currentWindowPermits);
                storedPermits += currentWindowPermits;
                currentWindowPermits = 0;
                while (deque.size() > windowSize) {
                    storedPermits -= deque.removeFirst();
                }
            }
        }
    }
}