java-QPS限制

QPS控制的目的

防止恶意刷取，增加项目负载

解决方案1(假设需要控制在1s内不多于400个请求)：

方案描述:
使用数组存储每个请求到来的时间，前400次请求顺利通过，并填满数组。
后续请求到来时，判断当前时间是否比数组中最早的时间晚1s，未晚，则打回，
晚则替换数组中最早的值。循环。

import java.util.Arrays;
import java.util.concurrent.TimeUnit;

public class WindowQpsControl {

    /**
 * 接受请求窗口
 */
    private Long[] accessWindow;
    /**
 * 窗口大小
 */
    private int limit;
    /**
 * 指针位置
 */
    private int curPosition;
    /**
 * 时间间隔
 */
    private long period;

    private final Object lock = new Object();

    /**
 * 1秒内最多400次请求
 * @param limit 限制次数 400
 * @param period 时间间隔 1
 * @param timeUnit 间隔类型 秒
 */
    public WindowQpsControl(int limit, int period, TimeUnit timeUnit) {
        if (limit < 0) {
            throw new IllegalArgumentException("Illegal Capacity: " + limit);
        }
        curPosition = 0;
        this.period = timeUnit.toMillis(period);
        this.limit = limit;
        accessWindow = new Long[limit];
        Arrays.fill(accessWindow, 0);
    }

    public boolean isPass() {
        long curTime = System.currentTimeMillis();
        synchronized (lock) {
            if (curTime >= period + accessWindow[curPosition]) {
                accessWindow[curPosition++] = curTime;
                curPosition = curPosition % limit;
                return true;
            } else {
                return false;
            }
        }
    }
}

解决方案2(假设需要控制在1s内不多于400个请求)：

方案描述：
使用两个辅助变量：limitPoint：当前时间点，初始化为当前时间
count：通过的访问数，初始化为0，没接收一次请求，自加1
count <= 400时请求可以顺利通过，每通过一次，count++；
count > 400请求到来时，判断当前时间是否比limitPoint晚1s，未晚1s，打回；
满则将limitPoint置为当前时间，count置0。循环。

import java.util.concurrent.TimeUnit;


public class PointQpsControl {

    private long limitPoint;

    private int count = 0;
    /**
 * 窗口大小
 */
    private int limit;
    /**
 * 时间间隔
 */
    private long period;

    private final Object lock = new Object();

    /**
 * 1秒内最多400次请求
 * @param limit 限制次数
 * @param period 时间间隔
 * @param timeUnit 间隔类型
 */
    public PointQpsControl(int limit, int period, TimeUnit timeUnit) {
        limitPoint = System.currentTimeMillis();
        curPosition = 0;
        this.period = timeUnit.toMillis(period);
        this.limit = limit;
    }


    public boolean isPass() {
        long curTime = System.currentTimeMillis();
        synchronized (lock) {
            if (count > limit) {
                if (curTime - limitPoint > period) {
                    limitPoint = curTime;
                    count = 0;
                    return true;
                } else {
                    return false;
                }
            } else {
                count++;
                return true;
            }
        }
    }
}

对比
空间效率	严格说，方案一中的时间窗口需要额外的数组存储，较方案二，浪费空间
时间效率	严格说，方案一需要数组存储，数组存于堆中，较方案二，读写慢
稳定性	方案一可以保证在任意时间段（1s）内，请求数不超过400。方案二可能出现在某个时间段（1s）内，接收的请求数达到800