Java实现限流算法（四种）Demo

CocoaAndYy

已于 2024-10-05 14:39:17 修改

阅读量663

点赞数 10

文章标签： java 算法开发语言

于 2024-10-05 11:12:50 首次发布

本文链接：https://blog.csdn.net/m0_45164511/article/details/142711476

版权

1.固定窗口限流

1.1 代码实现

1.2 postman测试（批量测试20次）

1.固定窗口限流

1.1 代码实现

public class FixWindowLimiter {
    /**
     * 每秒限制请求数
     */
    private static final long perSecondLimit = 2;
    /**
     * 上一个窗口的开始时间
     */
    public static long preStartTime = System.currentTimeMillis();
    /**
     * 计数器
     */
    private static int counter;
 
    public static synchronized boolean tryAcquire() {
        long now = System.currentTimeMillis();
        // 假设窗口时间位1秒，在窗口期内判断计数器是否超过限制的请求数
        if (now - preStartTime < 1000) {
        	// 计数器小于限制数时放行，否则拒绝请求
            if (counter < perSecondLimit) {
                counter++;
                return true;
            } else {
                return false;
            }
        }
        // 时间窗口过期，重置计数器和时间戳
        counter = 0;
        preStartTime = now;
        return true;
    }
}

这里限定每秒内的请求数为2，当请求数大于2的时候，拒绝请求。下面是测试的controller

@Controller
public class infoController {
    @GetMapping("/fix")
    @ResponseBody
    public String fix(String name){
        System.out.println(name);
        if (FixWindowLimiter.tryAcquire()){
            return "true";
        }else{
            return "false";
        }
    }
}

1.2 postman测试（批量测试20次）

前两次返回true，说明请求可以正常访问程序；第三次返回false，说明请求被限流。

1.3 优缺点

优点：

实现简单，容易理解。
适用于突发流量较小的场景。

缺点：

无法处理时间窗口的临界突变问题。
对于高并发场景，难以保证系统稳定性。
无法实现更加精细的限流控制。

2.滑动窗口限流

滑动窗口算法相当于对固定窗口算法的一种改进。在滑动窗口算法中，主要是通过维护一个固定大小的时间窗口，并随着时间的推移向前滑动来计算窗口内的请求总数。这样可以在不牺牲实时性的情况下，平滑地处理流量变化。

2.1 代码实现

package com.cocoa.rateLimiter;

import java.util.concurrent.TimeUnit;

public class SlidingWindowLimiter {
    // 固定时间窗口大小，单位毫秒
    private long windowSize;
    // 固定窗口拆分的小窗口数
    private int windowNum;
    // 每个窗口允许通过最大请求数
    private int maxRequestCount;
    // 各个窗口内请求计数
    private int[] perWindowCount;
    // 请求总数
    private int totalCount;
    // 当前窗口下标
    private int windowId;
    // 每个小窗口大小，毫秒
    private long perWindowSize;
    // 窗口右边界
    private long windowRightBorder;
    
    /**
     * 构造函数
     * 
     * @param windowSize 固定时间窗口大小
     * @param windowNum 固定窗口拆分的小窗口数
     * @param maxRequestCount  每个窗口允许通过最大请求数
     */
    public SlidingWindowLimiter(long windowSize, int windowNum, int maxRequestCount) {
        this.windowSize = windowSize;
        this.windowNum = windowNum;
        this.maxRequestCount = maxRequestCount;
        perWindowCount = new int[windowNum];
        perWindowSize = windowSize / windowNum;
        windowRightBorder = System.currentTimeMillis();
    }
    
    /**
     * 限流方法
     * @return
     */
    public synchronized boolean tryAcquire() {
        long currentTime = System.currentTimeMillis();
        if (currentTime > windowRightBorder){// 窗口移动
            do {
                windowId = (++windowId) % windowNum;
                totalCount -= perWindowCount[windowId];
                perWindowCount[windowId]=0;
                windowRightBorder += perWindowSize;
            }while (windowRightBorder < currentTime);
        }
        if (totalCount < maxRequestCount){
            System.out.println("tryAcquire success, windowId = "+windowId);
            perWindowCount[windowId]++;
            totalCount++;
            return true;
        }else{
            System.out.println("tryAcquire fail, windowId = "+windowId);
            return false;
        }
    }
	
	/**
     * 测试方法
     * @param args
     * @throws InterruptedException
     */
	public static void main(String[] args) throws InterruptedException {
        // 10个小窗口，每个窗口100ms， 可以接收的最大请求数为10
        SlidingWindowLimiter slidingWindowLimiter = new SlidingWindowLimiter(1000, 10, 10);
        //TimeUnit.MILLISECONDS.sleep(900);// 构建窗口
        for (int i = 0; i < 40; i++) {
            boolean acquire = slidingWindowLimiter.tryAcquire();
            if (acquire){
                System.out.println("任务" + (i + 1)  + "执行任务 " + System.currentTimeMillis());
            }else{
                System.out.println("任务" + (i + 1) + "被限流 "+ System.currentTimeMillis());
            }
            TimeUnit.MILLISECONDS.sleep(50);
        }
    }
}

2.2 测试说明

每个任务延时50ms，测试结果如下：前10个任务正常执行，后面的任务被拒绝。

前10次将窗口占满，后续部分窗口移动。