如何用Redis实现限流？

买女孩的火柴盒

于 2024-06-21 09:23:54 发布

阅读量93

点赞数

文章标签： redis 数据库缓存

原文链接：https://mp.weixin.qq.com/s/-Fv_32pV4QPaKqjVPpItNA

版权

在现代Web应用中，限流是一个常见的需求。它用于控制请求速率，防止恶意请求或突发流量导致服务器过载。Redis作为一个高性能的内存数据存储，可以很好地实现限流。本文将详细介绍如何使用Redis实现限流，包括各种限流算法及其实现方式。

为什么要使用Redis实现限流？

Redis具有以下特点，使其非常适合用于限流：

高性能：作为内存数据库，Redis 具有极高的读写速度。
丰富的数据结构：Redis提供多种数据结构，如字符串、哈希、列表、集合、有序集合等，可以灵活实现各种限流算法。
原子操作：Redis提供的多种命令都是原子的，确保在高并发环境下操作的正确性。
分布式支持：Redis可以通过集群模式扩展，以支持大规模的分布式限流需求。

常见的限流算法

固定窗口限流（Fixed Window Rate Limiting）
滑动窗口限流（Sliding Window Rate Limiting）
令牌桶算法（Token Bucket）
漏桶算法（Leaky Bucket）

1. 固定窗口限流

固定窗口限流算法将时间划分为多个固定大小的窗口，在每个窗口内限制请求次数。例如，每分钟不超过 100 次请求。

实现步骤

设置一个键，表示当前窗口及其请求计数。
检查请求计数，如果小于限制，则允许请求，并增加计数；否则拒绝请求。

窗口到期，重置计数。


import redis.clients.jedis.Jedis;

public class FixedWindowRateLimiter {
    private Jedis jedis;
    private int limit;
    private int windowSizeInSeconds;

    public FixedWindowRateLimiter(Jedis jedis, int limit, int windowSizeInSeconds) {
        this.jedis = jedis;
        this.limit = limit;
        this.windowSizeInSeconds = windowSizeInSeconds;
    }

    public boolean isAllowed(String key) {
        long currentWindow = System.currentTimeMillis() / 1000 / windowSizeInSeconds;
        String redisKey = key + ":" + currentWindow;
        long count = jedis.incr(redisKey);
        if (count == 1) {
            jedis.expire(redisKey, windowSizeInSeconds);
        }
        return count <= limit;
    }
}

滑动窗口限流

滑动窗口限流在固定窗口的基础上引入滑动机制，通过对多个较小的时间片计数，来实现更精细的限流控制。

实现步骤

记录每个请求的时间戳，并存入有序集合。
移除过期请求，保留当前窗口内的请求记录。

计算当前窗口内的请求数，判断是否超出限制。

import redis.clients.jedis.Jedis;
import redis.clients.jedis.params.ZAddParams;

public class SlidingWindowRateLimiter {
    private Jedis jedis;
    private int limit;
    private int windowSizeInSeconds;

    public SlidingWindowRateLimiter(Jedis jedis, int limit, int windowSizeInSeconds) {
        this.jedis = jedis;
        this.limit = limit;
        this.windowSizeInSeconds = windowSizeInSeconds;
    }

    public boolean isAllowed(String key) {
        long now = System.currentTimeMillis();
        long windowStart = now - windowSizeInSeconds * 1000;
        String redisKey = key;

        // 使用有序集合记录请求时间
        jedis.zremrangeByScore(redisKey, 0, windowStart);
        jedis.zadd(redisKey, now, String.valueOf(now));
        long count = jedis.zcard(redisKey);

        // 设置键的过期时间
        jedis.expire(redisKey, windowSizeInSeconds);

        return count <= limit;
    }
}

令牌桶算法

令牌桶算法是一个常见的流控算法，允许突发流量，但会限制平均请求速率。

实现步骤

初始化桶，桶中有一定数量的令牌。
定时添加令牌，按固定速率向桶中添加令牌。

请求时消耗令牌，桶中有足够令牌时允许请求，否则拒绝。


import redis.clients.jedis.Jedis;

public class TokenBucketRateLimiter {
    private Jedis jedis;
    private int maxTokens;
    private int refillRate;
    private long lastRefillTimestamp;

    public TokenBucketRateLimiter(Jedis jedis, int maxTokens, int refillRate) {
        this.jedis = jedis;
        this.maxTokens = maxTokens;
        this.refillRate = refillRate;
        this.lastRefillTimestamp = System.currentTimeMillis();
    }

    public boolean isAllowed(String key) {
        long now = System.currentTimeMillis();
        long refillTokens = (now - lastRefillTimestamp) / 1000 * refillRate;
        if (refillTokens > 0) {
            jedis.incrBy(key, refillTokens);
            jedis.setex(key + ":timestamp", 3600, String.valueOf(now));
            lastRefillTimestamp = now;
        }

        long tokens = jedis.decr(key);
        if (tokens < 0) {
            jedis.incr(key); // 恢复消耗的令牌
            return false;
        }
        return true;
    }
}

漏桶算法

漏桶算法将请求放入一个漏桶中，按固定速率处理请求。如果请求流量超过桶的容量，则拒绝请求。

实现步骤

初始化漏桶，设置桶的容量和处理速率。
请求时放入漏桶，桶未满时允许请求，否则拒绝。

定时处理桶中的请求，按固定速率处理请求。

import redis.clients.jedis.Jedis;

public class LeakyBucketRateLimiter {
    private Jedis jedis;
    private int capacity;
    private int leakRate;
    private long lastLeakTimestamp;

    public LeakyBucketRateLimiter(Jedis jedis, int capacity, int leakRate) {
        this.jedis = jedis;
        this.capacity = capacity;
        this.leakRate = leakRate;
        this.lastLeakTimestamp = System.currentTimeMillis();
    }

    public boolean isAllowed(String key) {
        long now = System.currentTimeMillis();
        long leaked = (now - lastLeakTimestamp) / 1000 * leakRate;
        if (leaked > 0) {
            jedis.decrBy(key, leaked);
            jedis.setex(key + ":timestamp", 3600, String.valueOf(now));
            lastLeakTimestamp = now;
        }

        long tokens = jedis.incr(key);
        if (tokens > capacity) {
            jedis.decr(key); // 恢复增加的令牌
            return false;
        }
        return true;
    }
}