Redis限流的幾種實現

public class RedisLimiterTest {
    private Jedis jedis;

    public RedisLimiterTest(Jedis jedis) {
        this.jedis = jedis;
    }

    /**
     * @param ipAddress Ip地址
     * @param period    特定的時間內，單位秒
     * @param maxCount  最大允許的次數
     * @return
     */
    public boolean isIpLimit(String ipAddress, int period, int maxCount) {
        String key = String.format("ip:%s", ipAddress);
        // 毫秒時間戳
        long currentTimeMillis = System.currentTimeMillis();
        Pipeline pipe = jedis.pipelined();
        // redis事務，保證原子性
        pipe.multi();
        // 存放數據，value 和 score 都使用毫秒時間戳
        pipe.zadd(key, currentTimeMillis, "" + UUID.randomUUID());
        // 移除窗口區間所有的元素
        pipe.zremrangeByScore(key, 0, currentTimeMillis - period * 1000);
        // 獲取時間窗口內的行為數量
        Response<Long> count = pipe.zcard(key);
        // 設置 zset 過期時間，避免冷用戶持續占用內存，這裡寬限1s
        pipe.expire(key, period + 1);
        // 提交事務
        pipe.exec();
        pipe.close();
        // 比較數量是否超標
        return count.get() > maxCount;
    }

    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);
        RedisLimiterTest limiter = new RedisLimiterTest(jedis);
        for (int i = 1; i <= 20; i++) {
            // 驗證IP  10秒鐘之內隻能訪問5次
            boolean isLimit = limiter.isIpLimit("222.73.55.22", 10, 5);
            System.out.println("訪問第" + i + "次, 結果：" + (isLimit ? "限制訪問" : "允許訪問"));
        }
    }
}

public class FunnelLimiterTest {

    static class Funnel {
        int capacity; // 漏鬥容量
        float leakingRate; // 漏嘴流水速率
        int leftQuota; // 漏鬥剩餘空間
        long leakingTs; // 上一次漏水時間

        public Funnel(int capacity, float leakingRate) {
            this.capacity = capacity;
            this.leakingRate = leakingRate;
            this.leftQuota = capacity;
            this.leakingTs = System.currentTimeMillis();
        }

        void makeSpace() {
            long nowTs = System.currentTimeMillis();
            long deltaTs = nowTs - leakingTs; // 距離上一次漏水過去瞭多久
            int deltaQuota = (int) (deltaTs * leakingRate); // 騰出的空間 = 時間*漏水速率
            if (deltaQuota < 0) { // 間隔時間太長，整數數字過大溢出
                this.leftQuota = capacity;
                this.leakingTs = nowTs;
                return;
            }
            if (deltaQuota < 1) { // 騰出空間太小 就等下次，最小單位是1
                return;
            }
            this.leftQuota += deltaQuota; // 漏鬥剩餘空間 = 漏鬥剩餘空間 + 騰出的空間
            this.leakingTs = nowTs;
            if (this.leftQuota > this.capacity) { // 剩餘空間不得高於容量
                this.leftQuota = this.capacity;
            }
        }

        boolean watering(int quota) {
            makeSpace();
            if (this.leftQuota >= quota) { // 判斷剩餘空間是否足夠
                this.leftQuota -= quota;
                return true;
            }
            return false;
        }
    }

    // 所有的漏鬥
    private Map<String, Funnel> funnels = new HashMap<>();

    /**
     * @param capacity    漏鬥容量
     * @param leakingRate 漏嘴流水速率 quota/s
     */
    public boolean isIpLimit(String ipAddress, int capacity, float leakingRate) {
        String key = String.format("ip:%s", ipAddress);
        Funnel funnel = funnels.get(key);
        if (funnel == null) {
            funnel = new Funnel(capacity, leakingRate);
            funnels.put(key, funnel);
        }
        return !funnel.watering(1); // 需要1個quota
    }

    public static void main(String[] args) throws Exception{
        FunnelLimiterTest limiter = new FunnelLimiterTest();
        for (int i = 1; i <= 50; i++) {
            // 每1s執行一次
            Thread.sleep(1000);
            // 漏鬥容量是2 ，漏嘴流水速率是0.5每秒，
            boolean isLimit = limiter.isIpLimit("222.73.55.22", 2, (float)0.5/1000);
            System.out.println("訪問第" + i + "次, 結果：" + (isLimit ? "限制訪問" : "允許訪問"));
        }
    }
}

> cl.throttle key:xxx 15 30 60 1

> cl.throttle laoqian:reply 15 30 60
1) (integer) 0   # 0 表示允許，1表示拒絕
2) (integer) 15  # 漏鬥容量capacity
3) (integer) 14  # 漏鬥剩餘空間left_quota
4) (integer) -1  # 如果拒絕瞭，需要多長時間後再試(漏鬥有空間瞭，單位秒)
5) (integer) 2   # 多長時間後，漏鬥完全空出來(left_quota==capacity，單位秒)