Redis实现分布式限流的几种方法
更新时间：2026年01月11日 10:05:58 作者：辞暮尔尔-烟火年年
Redis实现分布式限流能有效防止系统过载,,可以防止系统过载并确保公平的资源分配,主要算法包括固定窗口、滑动窗口和令牌桶,具有一定的参考价值,感兴趣的可以了解一下
使用Redis实现分布式限流是一种常见且有效的方法，可以防止系统过载并确保公平的资源分配。Redis的高性能和丰富的数据结构使其成为实现分布式限流的理想选择。常见的限流算法包括固定窗口计数、滑动窗口计数和令牌桶算法。
1. 固定窗口计数算法
固定窗口计数算法将时间划分为固定长度的窗口，并在每个窗口内计数请求的数量。
示例代码
以下示例展示了如何使用Redis实现固定窗口计数算法的分布式限流：
import redis.clients.jedis.Jedis;
public class FixedWindowRateLimiter {
private Jedis jedis;
private int maxRequests;
private int windowSize; // 窗口大小，单位为秒
public FixedWindowRateLimiter(String host, int port, int maxRequests, int windowSize) {
this.jedis = new Jedis(host, port);
this.maxRequests = maxRequests;
this.windowSize = windowSize;
}
public boolean isAllowed(String clientId) {
String key = "rate_limiter:" + clientId;
long currentWindow = System.currentTimeMillis() / 1000 / windowSize;
String windowKey = key + ":" + currentWindow;
long requestCount = jedis.incr(windowKey);
if (requestCount == 1) {
jedis.expire(windowKey, windowSize);
}
return requestCount <= maxRequests;
}
public void close() {
jedis.close();
}
public static void main(String[] args) {
FixedWindowRateLimiter rateLimiter = new FixedWindowRateLimiter("localhost", 6379, 5, 60);
for (int i = 0; i < 10; i++) {
boolean allowed = rateLimiter.isAllowed("client1");
System.out.println("Request " + (i + 1) + " allowed: " + allowed);
try {
Thread.sleep(500); // 模拟请求间隔
} catch (InterruptedException e) {
e.printStackTrace();
}
}
rateLimiter.close();
}
}
2. 滑动窗口计数算法
滑动窗口计数算法通过记录多个小窗口内的请求数，计算滑动窗口内的总请求数。
示例代码
以下示例展示了如何使用Redis实现滑动窗口计数算法的分布式限流：
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;
import java.util.List;
public class SlidingWindowRateLimiter {
private Jedis jedis;
private int maxRequests;
private int windowSize; // 窗口大小，单位为秒
private int interval; // 时间间隔，单位为秒
public SlidingWindowRateLimiter(String host, int port, int maxRequests, int windowSize, int interval) {
this.jedis = new Jedis(host, port);
this.maxRequests = maxRequests;
this.windowSize = windowSize;
this.interval = interval;
}
public boolean isAllowed(String clientId) {
String key = "rate_limiter:" + clientId;
long currentTime = System.currentTimeMillis() / 1000;
long windowStart = currentTime - windowSize;
Transaction transaction = jedis.multi();
transaction.zadd(key, currentTime, String.valueOf(currentTime));
transaction.zremrangeByScore(key, 0, windowStart);
transaction.zcard(key);
transaction.expire(key, windowSize + interval);
List<Object> results = transaction.exec();
long requestCount = (long) results.get(2);
return requestCount <= maxRequests;
}
public void close() {
jedis.close();
}
public static void main(String[] args) {
SlidingWindowRateLimiter rateLimiter = new SlidingWindowRateLimiter("localhost", 6379, 5, 60, 1);
for (int i = 0; i < 10; i++) {
boolean allowed = rateLimiter.isAllowed("client1");
System.out.println("Request " + (i + 1) + " allowed: " + allowed);
try {
Thread.sleep(500); // 模拟请求间隔
} catch (InterruptedException e) {
e.printStackTrace();
}
}
rateLimiter.close();
}
}
3. 令牌桶算法
令牌桶算法通过生成令牌来控制请求的速率。每次请求需要消耗一个令牌，如果桶中没有令牌，则请求被拒绝。
示例代码
以下示例展示了如何使用Redis实现令牌桶算法的分布式限流：
import redis.clients.jedis.Jedis;
public class TokenBucketRateLimiter {
private Jedis jedis;
private int maxTokens;
private int refillRate; // 令牌生成速率，单位为令牌/秒
public TokenBucketRateLimiter(String host, int port, int maxTokens, int refillRate) {
this.jedis = new Jedis(host, port);
this.maxTokens = maxTokens;
this.refillRate = refillRate;
}
public boolean isAllowed(String clientId) {
String key = "rate_limiter:" + clientId;
long currentTime = System.currentTimeMillis() / 1000;
long lastRefillTime = jedis.hget(key, "lastRefillTime") == null ?
0 : Long.parseLong(jedis.hget(key, "lastRefillTime"));
int tokens = jedis.hget(key, "tokens") == null ?
maxTokens : Integer.parseInt(jedis.hget(key, "tokens"));
long tokensToAdd = (currentTime - lastRefillTime) * refillRate;
tokens = Math.min(maxTokens, tokens + (int) tokensToAdd);
lastRefillTime = currentTime;
if (tokens > 0) {
jedis.hset(key, "tokens", String.valueOf(tokens - 1));
jedis.hset(key, "lastRefillTime", String.valueOf(lastRefillTime));
return true;
} else {
jedis.hset(key, "tokens", String.valueOf(tokens));
jedis.hset(key, "lastRefillTime", String.valueOf(lastRefillTime));
return false;
}
}
public void close() {
jedis.close();
}
public static void main(String[] args) {
TokenBucketRateLimiter rateLimiter = new TokenBucketRateLimiter("localhost", 6379, 5, 1);
for (int i = 0; i < 10; i++) {
boolean allowed = rateLimiter.isAllowed("client1");
System.out.println("Request " + (i + 1) + " allowed: " + allowed);
try {
Thread.sleep(500); // 模拟请求间隔
} catch (InterruptedException e) {
e.printStackTrace();
}
}
rateLimiter.close();
}
}
4. 令牌桶算法与Lua脚本
为了确保限流操作的原子性，可以使用Redis的Lua脚本。以下示例展示了如何结合Lua脚本和令牌桶算法来实现分布式限流。
Lua脚本
保存为token_bucket.lua：
local key = KEYS[1]
local maxTokens = tonumber(ARGV[1])
local refillRate = tonumber(ARGV[2])
local currentTime = tonumber(ARGV[3])
local tokens = tonumber(redis.call("hget", key, "tokens") or maxTokens)
local lastRefillTime = tonumber(redis.call("hget", key, "lastRefillTime") or 0)
local tokensToAdd = math.floor((currentTime - lastRefillTime) * refillRate)
tokens = math.min(maxTokens, tokens + tokensToAdd)
lastRefillTime = currentTime
if tokens > 0 then
redis.call("hset", key, "tokens", tokens - 1)
redis.call("hset", key, "lastRefillTime", lastRefillTime)
return 1
else
redis.call("hset", key, "tokens", tokens)
redis.call("hset", key, "lastRefillTime", lastRefillTime)
return 0
end
Java代码
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
public class TokenBucketRateLimiterWithLua {
private JedisPool jedisPool;
private String luaScript;
private String scriptSha;
public TokenBucketRateLimiterWithLua(String host, int port, String scriptPath) throws IOException {
this.jedisPool = new JedisPool(host, port);
this.luaScript = new String(Files.readAllBytes(Paths.get(scriptPath)));
try (Jedis jedis = jedisPool.getResource()) {
this.scriptSha = jedis.scriptLoad(luaScript);
}
}
public boolean isAllowed(String clientId, int maxTokens, int refillRate) {
String key = "rate_limiter:" + clientId;
long currentTime = System.currentTimeMillis() / 1000;
到此这篇关于Redis实现分布式限流的几种方法 的文章就介绍到这了,更多相关Redis 分布式限流内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
Unable to connect to Redis无法连接到Redis解决的全过程
这篇文章主要给大家介绍了关于Unable to connect to Redis无法连接到Redis解决的相关资料,文中通过图文以及实例代码将解决的过程介绍的非常详细,需要的朋友可以参考下2023-03-03
Redis 是一个高性能的键值对数据库,广泛应用于缓存、消息队列等场景,为了保障 Redis 服务的安全性,设置密码认证是非常重要的一步,所以本文给大家介绍了为Redis设置密码的三种方法,需要的朋友可以参考下2024-11-11
RedisDesktopManager远程连接redis的实现
本文主要介绍了RedisDesktopManager远程连接redis的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧2022-05-05
Redis String 类型和 Hash 类型学习笔记与总结
这篇文章主要介绍了Redis String 类型和 Hash 类型学习笔记与总结,本文分别对String 类型的一些方法和Hash 类型做了详细介绍,需要的朋友可以参考下2015-06-06
Redis是一款高性能的Key-Value数据库,其开源免费且具有高可用性等,本文主要介绍了使用rpm包安装redis的方法,具有一定的参考价值,感兴趣的可以了解一下2023-09-09
这篇文章主要介绍了redis之数据过期清除策略、缓存淘汰策略的用法,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教2025-04-04
本文详细介绍了Redis的基础知识、核心数据结构与命令、高级功能与命令、最佳实践与性能优化,以及实战应用场景,通过实战案例,展示了如何使用Redis构建高性能应用系统,感兴趣的朋友跟随小编一起看看吧2025-11-11
ELK配置转存redis缓存采集nginx访问日志的操作方法
本文介绍了在服务器上部署MySQL及如何启动MySQL服务,并详细说明了如何查找安装软件的日志文件位置,通过使用rpm命令查询MySQL服务的日志文件位置,以及通过编辑Logstash配置文件来添加MySQL日志信息,感兴趣的朋友一起看看吧2024-11-11
这篇文章主要介绍了Redis为什么快如何实现高可用及持久化,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下2020-12-12
本文主要介绍了redis使用zset实现延时队列的示例代码，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧2023-06-06
最新评论