好的，我们开始今天的讲座，主题是：Java 如何实现请求限流？结合 Redis + Guava 实现令牌桶算法。
今天我们来探讨一个在构建高可用、高性能系统时至关重要的话题：请求限流。当我们的服务面临突发流量或恶意攻击时，限流可以有效地保护系统，防止雪崩效应。我们将深入了解如何使用 Java，并结合 Redis 和 Guava 库来实现令牌桶算法，从而构建一个高效且可扩展的限流解决方案。
1. 限流的必要性
在讨论具体实现之前，我们先来明确一下限流的重要性。想象一下，你的在线商店突然因为一次促销活动涌入了十倍于平时的流量。如果没有限流机制，后端服务器可能会不堪重负，导致服务响应变慢甚至崩溃，最终影响用户体验和业务收入。
限流的主要目的是：
- 保护系统: 防止恶意攻击（如 DDoS）和突发流量压垮系统。
- 保证可用性: 确保系统在高峰期仍能提供稳定可靠的服务。
- 优化资源利用: 避免因过度负载导致资源浪费。
- 提升用户体验: 避免因服务不稳定导致用户流失。
2. 常见的限流算法
常见的限流算法有很多，各有优缺点。这里我们主要介绍以下几种：
| 算法名称 | 优点 | 缺点 | 适用场景 |
|---|
3. 令牌桶算法
令牌桶算法是一种常用的流量整形和限流算法。 它的核心思想是：
- 令牌生成: 系统以恒定的速率生成令牌，放入令牌桶中。
- 请求获取令牌: 每个请求在被处理之前需要从令牌桶中获取一个令牌。
- 令牌不足: 如果令牌桶中没有足够的令牌，则拒绝该请求（或进行其他处理，如排队）。
优点：
- 平滑流量: 允许突发流量，只要令牌桶中有足够的令牌。
- 配置灵活: 可以通过调整令牌生成速率和令牌桶容量来控制流量。
- 易于实现: 算法逻辑相对简单，容易实现。
缺点：
- 参数调整: 需要根据实际情况调整令牌生成速率和令牌桶容量，以达到最佳效果。
4. 使用 Redis + Guava 实现令牌桶算法
我们可以利用 Redis 的原子操作和 Guava 的 RateLimiter 类来实现一个分布式令牌桶限流器。
4.1 引入依赖
首先，在你的 pom.xml 文件中添加以下依赖：
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.6.0</version> <!-- 请使用最新的版本 -->
</dependency>
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>30.1-jre</version> <!-- 请使用最新的版本 -->
</dependency>4.2 Redis 实现令牌桶
我们将使用 Redis 的 INCR 命令来实现令牌桶的计数。以下是一个简单的 Redis 限流器的实现：
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
public class RedisTokenBucket {
private final JedisPool jedisPool;
private final String bucketKey;
private final long capacity;
private final double refillRate; // 令牌生成速率，单位：令牌/秒
public RedisTokenBucket(String host, int port, String bucketKey, long capacity, double refillRate) {
JedisPoolConfig config = new JedisPoolConfig();
// 可以设置连接池的一些参数，例如最大连接数、最大空闲连接数等
this.jedisPool = new JedisPool(config, host, port);
this.bucketKey = bucketKey;
this.capacity = capacity;
this.refillRate = refillRate;
}
/**
* 尝试获取令牌
* @return true 如果获取到令牌，false 否则
*/
public boolean tryAcquire() {
try (Jedis jedis = jedisPool.getResource()) {
// 当前时间戳，单位：秒
long now = System.currentTimeMillis() / 1000;
String script =
"local bucketKey = KEYS[1]n" +
"local capacity = tonumber(ARGV[1])n" +
"local refillRate = tonumber(ARGV[2])n" +
"local now = tonumber(ARGV[3])n" +
"local lastRefillTimestamp = tonumber(redis.call('get', bucketKey .. ':last_refill') or 0)n" +
"local tokensToAdd = math.floor((now - lastRefillTimestamp) * refillRate)n" +
"local currentTokens = tonumber(redis.call('get', bucketKey .. ':tokens') or 0)n" +
"local newTokens = math.min(capacity, currentTokens + tokensToAdd)n" +
"if newTokens >= 1 thenn" +
" redis.call('set', bucketKey .. ':tokens', newTokens - 1)n" +
" redis.call('set', bucketKey .. ':last_refill', now)n" +
" return 1n" +
"elsen" +
" redis.call('set', bucketKey .. ':last_refill', now)n" +
" return 0n" +
"end";
Object result = jedis.eval(script, 1, bucketKey, String.valueOf(capacity), String.valueOf(refillRate), String.valueOf(now));
return result.equals(1L);
}
}
public void close() {
jedisPool.close();
}
public static void main(String[] args) throws InterruptedException {
// 示例用法
RedisTokenBucket tokenBucket = new RedisTokenBucket("localhost", 6379, "my_bucket", 10, 2); // 桶容量为10，每秒生成2个令牌
for (int i = 0; i < 20; i++) {
if (tokenBucket.tryAcquire()) {
System.out.println("请求 " + i + " 被允许");
} else {
System.out.println("请求 " + i + " 被拒绝");
}
Thread.sleep(200); // 模拟请求间隔
}
tokenBucket.close();
}
}代码解释：
RedisTokenBucket类: 封装了 Redis 连接池和令牌桶的逻辑。bucketKey: Redis 中用于存储令牌桶信息的键的前缀。capacity: 令牌桶的容量，即最多可以存储多少个令牌。refillRate: 令牌生成速率，单位是 令牌/秒。tryAcquire(): 尝试获取令牌的方法。- Lua 脚本: 使用 Lua 脚本来保证原子性。脚本执行以下步骤：
- 计算自上次填充令牌以来应该添加的令牌数量。
- 更新令牌桶中的令牌数量，不超过容量。
- 如果令牌桶中有足够的令牌（至少 1 个），则减少令牌数量并返回 1（表示获取成功）。
- 否则，返回 0（表示获取失败）。
close(): 关闭 Redis 连接池。
为什么使用 Lua 脚本？
使用 Lua 脚本是为了保证令牌桶操作的原子性。在分布式环境中，多个客户端可能同时尝试获取令牌，如果没有原子性保证，可能会出现并发问题，导致令牌数量不准确，从而影响限流效果。 Lua 脚本在 Redis 中是原子执行的，可以避免这种并发问题。
4.3 Guava RateLimiter 实现单机限流
Guava 的 RateLimiter 类提供了一个基于令牌桶算法的单机限流器。虽然它不能直接用于分布式环境，但可以作为每个节点的本地限流器，与 Redis 结合使用，实现更细粒度的限流。
import com.google.common.util.concurrent.RateLimiter;
public class GuavaRateLimiterExample {
private final RateLimiter rateLimiter;
public GuavaRateLimiterExample(double permitsPerSecond) {
this.rateLimiter = RateLimiter.create(permitsPerSecond);
}
public boolean tryAcquire() {
return rateLimiter.tryAcquire(); // 默认等待时间为0秒，立即返回
}
public static void main(String[] args) throws InterruptedException {
GuavaRateLimiterExample rateLimiterExample = new GuavaRateLimiterExample(5); // 每秒允许 5 个请求
for (int i = 0; i < 10; i++) {
if (rateLimiterExample.tryAcquire()) {
System.out.println("请求 " + i + " 被允许");
} else {
System.out.println("请求 " + i + " 被拒绝");
}
Thread.sleep(100); // 模拟请求间隔
}
}
}代码解释：
RateLimiter.create(permitsPerSecond): 创建一个RateLimiter实例，指定每秒允许的请求数量（permitsPerSecond）。rateLimiter.tryAcquire(): 尝试获取一个令牌。如果能在指定的时间内（默认为 0，即立即返回）获取到令牌，则返回true；否则返回false。
4.4 结合 Redis 和 Guava 实现分布式限流
现在，我们将 Redis 和 Guava 结合起来，实现一个更完善的分布式限流方案。
import com.google.common.util.concurrent.RateLimiter;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
public class DistributedRateLimiter {
private final JedisPool jedisPool;
private final String bucketKey;
private final long capacity;
private final double refillRate;
private final RateLimiter guavaRateLimiter; // 本地限流器
public DistributedRateLimiter(String host, int port, String bucketKey, long capacity, double refillRate, double localRateLimit) {
JedisPoolConfig config = new JedisPoolConfig();
this.jedisPool = new JedisPool(config, host, port);
this.bucketKey = bucketKey;
this.capacity = capacity;
this.refillRate = refillRate;
this.guavaRateLimiter = RateLimiter.create(localRateLimit);
}
public boolean tryAcquire() {
// 1. 本地限流
if (!guavaRateLimiter.tryAcquire()) {
return false;
}
// 2. 分布式限流
try (Jedis jedis = jedisPool.getResource()) {
long now = System.currentTimeMillis() / 1000;
String script =
"local bucketKey = KEYS[1]n" +
"local capacity = tonumber(ARGV[1])n" +
"local refillRate = tonumber(ARGV[2])n" +
"local now = tonumber(ARGV[3])n" +
"local lastRefillTimestamp = tonumber(redis.call('get', bucketKey .. ':last_refill') or 0)n" +
"local tokensToAdd = math.floor((now - lastRefillTimestamp) * refillRate)n" +
"local currentTokens = tonumber(redis.call('get', bucketKey .. ':tokens') or 0)n" +
"local newTokens = math.min(capacity, currentTokens + tokensToAdd)n" +
"if newTokens >= 1 thenn" +
" redis.call('set', bucketKey .. ':tokens', newTokens - 1)n" +
" redis.call('set', bucketKey .. ':last_refill', now)n" +
" return 1n" +
"elsen" +
" redis.call('set', bucketKey .. ':last_refill', now)n" +
" return 0n" +
"end";
Object result = jedis.eval(script, 1, bucketKey, String.valueOf(capacity), String.valueOf(refillRate), String.valueOf(now));
return result.equals(1L);
}
}
public void close() {
jedisPool.close();
}
public static void main(String[] args) throws InterruptedException {
// 示例用法
DistributedRateLimiter rateLimiter = new DistributedRateLimiter("localhost", 6379, "my_distributed_bucket", 10, 2, 3); // 桶容量为10，每秒生成2个令牌，本地限流每秒3个请求
for (int i = 0; i < 20; i++) {
if (rateLimiter.tryAcquire()) {
System.out.println("请求 " + i + " 被允许");
} else {
System.out.println("请求 " + i + " 被拒绝");
}
Thread.sleep(100); // 模拟请求间隔
}
rateLimiter.close();
}
}代码解释：
localRateLimit: 本地限流器的速率，单位是 请求/秒。guavaRateLimiter: Guava 的RateLimiter实例，用于本地限流。tryAcquire(): 首先尝试从本地限流器获取令牌，如果获取失败，则直接返回false。如果本地限流通过，则继续尝试从 Redis 获取令牌。- 先进行本地限流的原因： 减少对 Redis 的访问，提高性能。只有通过本地限流的请求才会访问 Redis，从而降低 Redis 的负载。
5. 进一步优化
- 连接池配置: 根据实际情况调整 Redis 连接池的配置，例如最大连接数、最大空闲连接数、连接超时时间等，以提高性能和稳定性。
- 监控和告警: 监控令牌桶的状态，例如剩余令牌数量、请求拒绝率等，并设置告警，以便及时发现和处理问题。
- 动态调整: 根据系统负载和业务需求，动态调整令牌生成速率和令牌桶容量。
- 不同的限流策略: 可以根据不同的业务场景，采用不同的限流策略，例如基于用户 ID 的限流、基于 IP 地址的限流等。
- 集成熔断器: 与熔断器集成，当 Redis 出现故障时，可以快速熔断，避免影响整个系统。
- 使用 Redis 集群: 如果Redis的单点写入成为瓶颈，可以考虑使用Redis集群来提高并发能力。
6. 总结一下关键点
本次讲座，我们深入探讨了请求限流的重要性，学习了几种常见的限流算法，重点讲解了如何使用 Java 结合 Redis 和 Guava 实现令牌桶算法。通过 Redis 保证了分布式环境下的原子性，Guava RateLimiter 实现了单机限流，二者结合，构建了一个更加完善和高效的限流解决方案。
7. 算法选择的关键点
选择合适的限流算法需要根据实际情况进行权衡。例如，如果需要平滑流量，可以选择令牌桶算法或漏桶算法；如果需要精确控制请求数量，可以选择计数器算法。
8. 分布式限流的关键点
在分布式环境中，需要保证限流的原子性。可以使用 Redis 的原子操作或 Lua 脚本来实现原子性。
9. 持续优化是关键
限流是一个持续优化的过程。需要根据实际情况调整限流参数，并监控限流效果，以便达到最佳的保护效果。