Java 分布式限流实战：Redisson RateLimiter 原理与使用

此外，Redisson 还使用 Lua 脚本 保证令牌获取操作的原子性，避免并发竞争。

限流流程

典型的 tryAcquire() 调用流程如下：

sequenceDiagram
    participant App as 应用实例
    participant Lua as Lua 脚本
    participant Redis as Redis Server
    
    App->>Lua: tryAcquire(1)
    Lua->>Redis: 执行限流逻辑
    Redis-->>Lua: 计算应生成的令牌数
    Redis-->>Lua: 更新当前令牌数
    Redis-->>Lua: 判断是否足够
    Lua-->>App: 返回 true / false

整个过程在 Redis 单线程中执行，确保强一致性。

快速上手：第一个 Redisson RateLimiter 示例

1. 添加依赖

首先，在 Maven 项目中引入 Redisson：

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.24.2</version>
</dependency>

2. 配置 RedissonClient

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;

public class RedissonConfig {
    public static RedissonClient createClient() {
        Config config = new Config();
        config.useSingleServer()
              .setAddress("redis://127.0.0.1:6379")
              .setPassword(null);
        return Redisson.create(config);
    }
}

3. 创建并使用 RateLimiter

import org.redisson.api.RRateLimiter;
import org.redisson.api.RateType;
import org.redisson.api.RedissonClient;
import java.util.concurrent.TimeUnit;

public class SimpleRateLimiterExample {
    public static void main(String[] args) {
        RedissonClient redisson = RedissonConfig.createClient();
        RRateLimiter limiter = redisson.getRateLimiter("api_limiter");

        // 初始化：每秒最多 5 个请求
        limiter.trySetRate(RateType.OVERALL, 5, 1, TimeUnit.SECONDS);

        // 模拟 10 次请求
        for (int i = 0; i < 10; i++) {
            boolean acquired = limiter.tryAcquire();
            System.out.println("Request " + i + ": " + (acquired ? "ALLOWED" : "DENIED"));
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        redisson.shutdown();
    }
}

⚠️ 注意：trySetRate() 只需在首次使用时调用一次。如果限流器已存在，再次调用不会生效。建议在应用启动时统一初始化。

RateLimiter 核心 API 详解

1. trySetRate(RateType type, long rate, long rateInterval, TimeUnit unit)

初始化限流器参数：

• type：OVERALL（所有实例共享总配额）或 PER_CLIENT（每个实例独立配额）。
• rate：在 rateInterval 时间内允许的请求数。

2. boolean tryAcquire()

尝试获取 1 个令牌，立即返回，不阻塞。返回 true 表示成功，false 表示令牌不足。

3. boolean tryAcquire(long permits)

尝试获取指定数量的令牌。

4. void acquire() 和 void acquire(long permits)

阻塞式获取，直到有足够令牌。适用于后台任务，Web 请求中慎用以免线程耗尽。

5. long availablePermits()

获取当前可用令牌数，主要用于调试。

6. void expire(long timeToLive, TimeUnit unit)

设置限流器的过期时间，避免 Redis 中残留无用数据。

高级用法与最佳实践

场景 1：API 接口限流（Web 应用）

在 Spring Boot 中，结合 AOP 或拦截器实现全局限流：

@RestController
public class ApiController {
    @Autowired
    private RedissonClient redisson;

    @GetMapping("/api/data")
    public String getData(@RequestParam String userId) {
        String key = "rate_limiter:user:" + userId;
        RRateLimiter limiter = redisson.getRateLimiter(key);
        limiter.trySetRate(RateType.OVERALL, 2, 1, TimeUnit.SECONDS);
        limiter.expire(300, TimeUnit.SECONDS);

        if (!limiter.tryAcquire()) {
            throw new RuntimeException("Too many requests");
        }
        return "Data for " + userId;
    }
}

场景 2：防止短信/邮件轰炸

public void sendSms(String phone) {
    String key = "sms_limiter:" + phone;
    RRateLimiter limiter = redisson.getRateLimiter(key);
    limiter.trySetRate(RateType.OVERALL, 3, 60, TimeUnit.SECONDS);

    if (!limiter.tryAcquire()) {
        log.warn("SMS limit exceeded for {}", phone);
        throw new BusinessException("发送太频繁，请稍后再试");
    }
    smsService.send(phone, "验证码：123456");
}

场景 3：分布式任务调度限流

@Scheduled(fixedRate = 5 * 60 * 1000)
public void scheduledTask() {
    RRateLimiter limiter = redisson.getRateLimiter("hourly_task");
    limiter.trySetRate(RateType.OVERALL, 10, 1, TimeUnit.HOURS);

    if (limiter.tryAcquire()) {
        doHeavyWork();
    } else {
        log.info("Hourly task limit reached, skip this round.");
    }
}

性能与可靠性分析

性能开销

• 网络延迟：每次 tryAcquire() 需要一次 Redis 往返（RTT）。
• Lua 脚本执行：Redis 单线程执行，通常耗时 < 0.1ms。
• 吞吐量：在千兆网络下，单 Redis 实例可支撑 10 万+ QPS 的限流判断。

可靠性保障

• 原子性：Lua 脚本保证操作不可分割。
• 持久化：配合 RDB/AOF 恢复状态，但建议容忍短暂不一致。
• 高可用：配合 Redis Sentinel 或 Cluster，避免单点故障。

限流器生命周期管理

为避免 Redis 中积累大量无用的限流器 Key，建议设置 TTL（expire()），并使用带过期策略的 Key 命名。

与其他限流方案对比

如果你已有 Redis 基础设施，Redisson RateLimiter 是轻量、易用、高效的选择。

常见问题与陷阱

1. 重复初始化问题

不要在每次请求中都调用 trySetRate()，这会导致低效且配置覆盖。应在应用启动时初始化，或使用 if (!limiter.isExists()) 判断。

2. 限流器 Key 设计不合理

避免使用动态拼接导致 Key 爆炸。建议按维度聚合：用户 ID、IP、API 路径等。

3. 忽略 Redis 故障

如果 Redis 不可用，限流器将失效。建议降级策略：Redis 不可用时，切换到本地限流（Guava）并监控告警。

4. 令牌桶容量误解

Redisson 的令牌桶没有显式容量上限，令牌数随时间累积，但不会超过 rate * n。例如：1 QPS，停 10 秒后，最多有 10 个令牌，允许突发 10 次。

扩展：自定义限流策略

虽然 Redisson 提供了标准令牌桶，但有时我们需要更复杂的逻辑，如组合限流或动态调整速率。

示例：组合限流（用户 + 全局）

public boolean checkRateLimit(String userId) {
    RRateLimiter global = redisson.getRateLimiter("global_api");
    global.trySetRate(RateType.OVERALL, 100, 1, TimeUnit.SECONDS);

    RRateLimiter user = redisson.getRateLimiter("user_api:" + userId);
    user.trySetRate(RateType.OVERALL, 5, 1, TimeUnit.SECONDS);

    return global.tryAcquire() && user.tryAcquire();
}

动态调整速率

Redisson 不支持直接修改速率，需要删除旧限流器并重建：

limiter.delete();
limiter.trySetRate(RateType.OVERALL, newRate, 1, TimeUnit.SECONDS);

⚠️ 删除限流器会导致当前令牌清零，需谨慎操作。

生产环境部署建议

1. Redis 配置优化

• 使用 独立 Redis 实例 存储限流数据。
• 开启 AOF 持久化，防止重启后限流失效。
• 设置 maxmemory 和 淘汰策略，防内存溢出。

2. 监控与告警

• 监控指标：tryAcquire() 失败率、Redis CPU 使用率、网络延迟。
• 告警条件：限流拒绝率 > 10%、Redis 连接池耗尽。

3. 压测验证

使用 JMeter 或 wrk 模拟高并发，验证限流准确性及系统响应时间稳定性。

总结

Redisson RateLimiter 以极低的开发成本，为你提供了企业级的分布式限流能力。无论是 API 网关、用户行为控制，还是后台任务调度，它都能胜任。

🌟 记住：限流不是目的，而是手段。合理的限流策略 + 完善的监控体系，才能构建真正健壮的系统。

参考资料

• Redisson 官方 Wiki
• Redis 官方文档 - Lua scripting
• Alibaba Sentinel
• Rate Limiting Algorithms Explained