Redis+Lua的分布式限流器

小满和小晨2025-08-04 17:51

核心原理

在分布式系统中，限流器需满足 原子性 和 跨进程一致性。Redis 提供高性能存储，Lua 脚本保证多命令原子执行，二者结合实现分布式限流。

常用限流算法

1、令牌桶算法 (Token Bucket)

  • 以恒定速率向桶内添加令牌

  • 请求消耗令牌，桶空时拒绝请求

  • 支持突发流量（桶内令牌可累积）

2、漏桶算法 (Leaky Bucket)

  • 请求以恒定速率流出

  • 超出桶容量时拒绝请求

Redis数据结构：

使用一个Hash结构来存储令牌桶的相关信息，包括：

  • tokens: 当前桶中的令牌数量。
  • last_time: 上次更新令牌桶的时间戳（单位：秒或毫秒）
Lua脚本设计：

脚本的主要逻辑如下：

  1. 获取当前时间（单位：秒，可以使用Redis的TIME命令获取）。
  2. 从Redis中读取令牌桶的当前状态（当前令牌数tokens和上次更新时间last_time）。
  3. 计算从上一次更新到现在这段时间内应该添加的令牌数（基于速率和经过的时间）。
  4. 更新当前令牌数（不能超过桶的容量）。
  5. 判断当前令牌数是否足够（至少需要1个令牌）：
    • 如果足够，则令牌数减1，并更新状态，返回允许（例如返回1）。
    • 如果不足，则返回拒绝（例如返回0）。

注意：由于令牌桶的更新需要原子性，所以整个计算和更新过程必须在一个Lua脚本中完成。

Lua脚本示例：
lua 复制代码 
local key = KEYS[1]            -- 限流器Key
local capacity = tonumber(ARGV[1]) -- 桶容量
local rate = tonumber(ARGV[2])    -- 令牌生成速率 (个/秒)
local now = tonumber(ARGV[3])     -- 当前时间戳(秒)
local requested = tonumber(ARGV[4]) -- 请求令牌数

-- 获取桶当前状态
local data = redis.call('HMGET', key, 'tokens', 'last_time')
local tokens
local last_time

-- 处理数据初始化及类型转换
if data[1] == false or data[1] == nil then
    tokens = capacity
else
    tokens = tonumber(data[1]) or capacity  -- 非数字时使用默认容量
end

if data[2] == false or data[2] == nil then
    last_time = now
else
    last_time = tonumber(data[2]) or now    -- 非数字时使用当前时间
end

-- 处理时间回拨问题（服务器时间调整）
if now < last_time then
    last_time = now  -- 重置最后时间为当前时间
end

-- 计算新增令牌（仅当时间正常流逝时）
local new_tokens = 0
if now > last_time then
    new_tokens = (now - last_time) * rate
end

-- 更新令牌数量（不超过桶容量）
tokens = math.min(capacity, tokens + new_tokens)

-- 判断是否允许请求
local allowed = false
if tokens >= requested then
    tokens = tokens - requested
    allowed = true
    -- 更新桶状态
    redis.call('HMSET', key, 'tokens', tokens, 'last_time', now)
    -- 设置Key过期时间（避免冷数据堆积）
    local ttl = math.ceil(capacity / rate) * 2
    redis.call('EXPIRE', key, ttl)
end

return allowed and 1 or 0

RedisRateLimiter 类

csharp 复制代码 
package com.wang.seckill.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.stereotype.Component;

import java.util.Collections;
import java.util.concurrent.TimeUnit;

/**
 * @author xiaoman
 */
@Component
public class RedisRateLimiter {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * lua脚本
     */
    private static final String RATE_LIMITER_LUA =
            "local key = KEYS[1]            \n" +
                    "local capacity = tonumber(ARGV[1]) \n" +
                    "local rate = tonumber(ARGV[2])    \n" +
                    "local now = tonumber(ARGV[3])     \n" +
                    "local requested = tonumber(ARGV[4]) \n" +
                    "local data = redis.call('HMGET', key, 'tokens', 'last_time') \n" +
                    "local tokens \n" +
                    "local last_time \n" +
                    "if data[1] == false or data[1] == nil then \n" +
                    "    tokens = capacity \n" +
                    "else \n" +
                    "    tokens = tonumber(data[1]) or capacity \n" +
                    "end \n" +
                    "if data[2] == false or data[2] == nil then \n" +
                    "    last_time = now \n" +
                    "else \n" +
                    "    last_time = tonumber(data[2]) or now \n" +
                    "end \n" +
                    "if now < last_time then \n" +
                    "    last_time = now \n" +
                    "end \n" +
                    "local new_tokens = 0 \n" +
                    "if now > last_time then \n" +
                    "    new_tokens = (now - last_time) * rate \n" +
                    "end \n" +
                    "tokens = math.min(capacity, tokens + new_tokens) \n" +
                    "local allowed = false \n" +
                    "if tokens >= requested then \n" +
                    "    tokens = tokens - requested \n" +
                    "    allowed = true \n" +
                    "    redis.call('HMSET', key, 'tokens', tokens, 'last_time', now) \n" +
                    "    local ttl = math.ceil(capacity / rate) * 2 \n" +
                    "    redis.call('EXPIRE', key, ttl) \n" +
                    "end \n" +
                    "return allowed and 1 or 0";

    // 预编译的 Redis 脚本（提升性能）
    private final RedisScript<Long> rateLimiterScript;

    public RedisRateLimiter() {
        // 在构造函数中预编译脚本
        DefaultRedisScript<Long> script = new DefaultRedisScript<>();
        script.setScriptText(RATE_LIMITER_LUA);
        script.setResultType(Long.class);
        this.rateLimiterScript = script;
    }

    /**
     * 尝试获取令牌
     * @param key 限流key（如：接口名+用户ID）
     * @param capacity 桶容量
     * @param rate 每秒补充的令牌数
     * @param requested 请求的令牌数（通常为1）
     * @return 是否允许
     */
    public boolean tryAcquire(String key, int capacity, int rate, int requested) {
        try {
            long now = TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis());

            Long result = stringRedisTemplate.execute(
                    rateLimiterScript,
                    Collections.singletonList(key),
                    String.valueOf(capacity),
                    String.valueOf(rate),
                    String.valueOf(now),
                    String.valueOf(requested)
            );

            // 处理可能的空结果
            return result != null && result == 1;

        } catch (Exception e) {
            // 根据业务需求选择降级策略
            // true = 允许通过（宽松模式） false = 拒绝请求（严格模式）
            return handleException(e);
        }
    }

    /**
     * 异常处理策略（可重写）
     */
    protected boolean handleException(Exception e) {
        // 默认降级策略：拒绝请求
        return false;

        // 生产环境可根据需要实现：
        // 1. 记录日志
        // 2. 根据异常类型选择策略
        // 3. 动态配置降级方案
    }
}
工作流程

初始化参数

  • capacity: 桶容量（突发最大请求数）

  • rate: 令牌生成速率（如 10 表示每秒10个）

  • requested: 本次请求消耗令牌数（通常为1）

调用和效果
csharp 复制代码 
    @PostMapping("/execute")
    public Result<String> secKill(@RequestBody SecKillParamVO paramVO) {
        if (paramVO == null) {
            return Result.error("入参为空");
        }
        paramVO.check();
        LOG.info("secKill:param:{}", paramVO);
        // 1. 用户维度限流（每个用户每秒最多5次请求）
        String userLimitKey = "seckill_limit:user:" + paramVO.getUserId();
        if (!limiter.tryAcquire(userLimitKey, 5, 5, 1)) {
            LOG.error("用户{}请求过于频繁，请稍后再试", paramVO.getUserId());
            return Result.error("请求过于频繁，请稍后再试");
        }

        // 2. 商品维度限流（每个商品每秒最多1000次请求）
        String itemLimitKey = "seckill_limit:item:" + paramVO.getItemId();
        if (!limiter.tryAcquire(itemLimitKey, 1000, 1000, 1)) {
            LOG.error("当前商品：{} 过于火爆，请稍后再试", paramVO.getItemId());

            return Result.error("当前商品过于火爆，请稍后再试");
        }
        // 秒杀业务
        String  result = secKillService.executeSecKill(paramVO.getUserId(), paramVO.getItemId());
        return Result.success(result);
    }
相关推荐
xiao-xiang2 小时前
zookeeper-保姆级配置说明
分布式·zookeeper·云原生·中间件·zk
万行3 小时前
点评项目（Redis中间件）&第一部分Redis基础
java·数据库·redis·缓存·中间件
Seven973 小时前
一文带你了解缓存和数据库一致性问题
redis·mysql
鸿蒙先行者5 小时前
鸿蒙分布式能力调用失败解决方案及案例
分布式·harmonyos
yourkin6666 小时前
RocketMQ 分布式事务方案
分布式·rocketmq
喪彪14 小时前
Ubuntu操作系统下使用mysql、mongodb、redis
redis·mysql·mongodb
lifallen15 小时前
Hadoop MapReduce 任务/输入数据 分片 InputSplit 解析
大数据·数据结构·hadoop·分布式·算法
Hello.Reader20 小时前
Kafka 4.0 从零到一8 步快速上手 + 实战要点与避坑
分布式·kafka
一叶飘零_sweeeet21 小时前
在分布式环境下正确使用MyBatis二级缓存
java·分布式·mybatis
2301_803554521 天前
redis学习
数据库·redis·学习
热门推荐
01UV安装并设置国内源02KGG转MP3工具|非KGM文件|解密音频03不再让Windows更新！&Edge游戏助手卸载及关闭自动更新04Qwen3-Coder 快速上手教程 | Qwen Code + Claude Code05【2025.08.06最新版】Android Studio下载、安装及配置记录（自动下载sdk）06突破百度网盘的下载限速，两种方法教会你【超详细】07Linux下V2Ray安装配置指南08Claude Code VSCode集成开发指南：AI编程助手完整配置0937、需求预测与库存优化 (快消品) - /供应链管理组件/fmcg-inventory-optimization10jdk21下载、安装（Windows、Linux、macOS）