Lua on Liangweidong's blog

分布式限流实战：Nginx + Tomcat + Guava + Redis Lua

Wed, 15 Sep 2021 00:00:00 +0800

本文写于 2021 年 9 月——彼时 Sentinel 已经在阿里系大规模落地，但中小厂仍以"自研 + Redis Lua"为主流。

一、限流分层架构

限流不是"做一次就够"，需要从边缘到核心层层设防：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


 ┌──────────┐
 用户请求 ───> │ CDN │ 第 1 层：CDN 限流（按地区/ISP）
 └────┬─────┘
 ▼
 ┌──────────┐
 │ Nginx │ 第 2 层：边缘网关限流（IP / 域名）
 └────┬─────┘
 ▼
 ┌──────────┐
 │ Tomcat │ 第 3 层：Web 容器限流（maxThreads）
 └────┬─────┘
 ▼
 ┌──────────┐
 │ 网关层 │ 第 4 层：Spring Cloud Gateway / Sentinel
 └────┬─────┘
 ▼
 ┌──────────┐
 │ 单体应用 │ 第 5 层：Guava RateLimiter
 └────┬─────┘
 ▼
 ┌──────────┐
 │ 分布式 │ 第 6 层：Redis + Lua 全局限流
 │ Redis │
 └──────────┘

核心思想：越靠近用户限流越粗（IP / 域名），越靠近业务限流越细（接口 / 用户）。

二、Nginx 限流（边缘网关层）

2.1 核心指令

Nginx 自带两个限流模块：

limit_req：限制请求速率（QPS）
limit_conn：限制并发连接数

2.2 完整配置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


# ===== 第一步：定义限流 zone（http 块）=====

# 根据 IP 限速：每秒 10 个请求
limit_req_zone $binary_remote_addr zone=iplimit:20m rate=10r/s;

# 根据 server 限速：每秒 1 个请求
limit_req_zone $server_name zone=serverlimit:10m rate=1r/s;

# 根据 IP 限并发：每个 IP 最多 100 个连接
limit_conn_zone $binary_remote_addr zone=perip:20m;

# 根据 server 限并发：每个 server 最多 100 个连接
limit_conn_zone $server_name zone=perserver:20m;

# ===== 第二步：在 location 应用 =====

server {
 server_name www.test.com;
 
 # 接口限流
 location /access-limit/ {
 proxy_pass http://127.0.0.1:8080/;
 
 # IP 限速（burst=2 允许瞬时 2 个排队，nodelay 不延迟立即处理）
 limit_req zone=iplimit burst=2 nodelay;
 # server 限速
 limit_req zone=serverlimit burst=2 nodelay;
 # IP 限并发 100
 limit_conn zone=perip 100;
 # server 限并发 100
 limit_conn zone=perserver 1;
 # 限流触发时返回 504（默认 503）
 limit_req_status 504;
 limit_conn_status 504;
 }
 
 # 限速下载
 location /download/ {
 # 前 100m 不限速
 limit_rate_after 100m;
 # 之后限速 256k/s
 limit_rate 256k;
 }
}

2.3 关键参数

burst=2：允许瞬时超出 rate 2 个请求排队等待
nodelay：排队不延迟，超出的请求立即返回 503（默认是延迟处理）
rate=10r/s：每秒 10 个请求（也支持 30r/m 每分钟 30 个）

三、Tomcat 限流（Web 容器层）

3.1 核心配置

Tomcat 8.5 通过 conf/server.xml 配置最大线程数：

1
2
3
4
5
6


<Connector port="8080"
 protocol="HTTP/1.1"
 connectionTimeout="20000"
 maxThreads="150" <!-- 最大线程数 -->
 acceptCount="100" <!-- 等待队列长度 -->
 redirectPort="8443" />

工作原理：

当并发请求 > maxThreads（默认 150）时，请求进入等待队列
等待队列满后，新请求被拒绝
天然限流

3.2 调优建议

小贴士：maxThreads 默认 150（Tomcat 8.5.42），但不是越大越好：

每开 1 个线程 → 1MB JVM 内存（线程栈）
线程越多 → GC 负担越重
OS 限制：Windows 每进程 ≤ 2000 线程，Linux 每进程 ≤ 1000 线程

经验值：8 核 16G 机器配 maxThreads=400 较合理，再多就是 GC 抖动的开始。

四、单体应用限流（Guava RateLimiter）

4.1 引入依赖

1
2
3
4
5
6


<!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
<dependency>
 <groupId>com.google.guava</groupId>
 <artifactId>guava</artifactId>
 <version>31.1-jre</version>
</dependency>

4.2 简单使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


@Slf4j
@RestController
@RequestMapping("/limit")
public class LimitController {
 
 // 限流策略：1 秒钟 2 个请求
 private final RateLimiter limiter = RateLimiter.create(2.0);
 
 @GetMapping("/test1")
 public String testLimiter() {
 // 500 毫秒内，没拿到令牌就降级
 boolean tryAcquire = limiter.tryAcquire(500, TimeUnit.MILLISECONDS);
 
 if (!tryAcquire) {
 log.warn("进入服务降级，时间{}", LocalDateTime.now());
 return "当前排队人数较多，请稍后再试！";
 }
 
 log.info("获取令牌成功，时间{}", LocalDateTime.now());
 return "请求成功";
 }
}

4.3 Guava 限流模式

模式	类	特点
平滑突发（SmoothBursty）	`RateLimiter.create(permitsPerSecond)`	启动即可满速率
平滑预热（SmoothWarmingUp）	`RateLimiter.create(permitsPerSecond, warmupPeriod, unit)`	启动后有预热期，逐步提到配置速率

4.4 自定义注解 + AOP（接口级限流）

注解：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
@Documented
public @interface Limit {
 String key() default ""; // 资源 key
 double permitsPerSecond(); // QPS
 long timeout(); // 最大等待时间
 TimeUnit timeunit() default TimeUnit.MILLISECONDS;
 String msg() default "系统繁忙,请稍后再试.";
}

AOP 切面：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


@Slf4j
@Aspect
@Component
public class LimitAop {
 
 private final Map<String, RateLimiter> limitMap = Maps.newConcurrentMap();
 
 @Around("@annotation(com.example.limit.Limit)")
 public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
 MethodSignature signature = (MethodSignature) joinPoint.getSignature();
 Method method = signature.getMethod();
 Limit limit = method.getAnnotation(Limit.class);
 
 if (limit != null) {
 String key = limit.key();
 RateLimiter rateLimiter = limitMap.computeIfAbsent(
 key, k -> RateLimiter.create(limit.permitsPerSecond())
 );
 
 // 拿令牌
 boolean acquire = rateLimiter.tryAcquire(limit.timeout(), limit.timeunit());
 if (!acquire) {
 log.debug("令牌桶={}，获取令牌失败", key);
 this.responseFail(limit.msg());
 return null;
 }
 }
 return joinPoint.proceed();
 }
 
 private void responseFail(String msg) {
 HttpServletResponse response = ((ServletRequestAttributes) 
 RequestContextHolder.getRequestAttributes()).getResponse();
 ResultData<Object> resultData = ResultData.fail(ReturnCode.LIMIT_ERROR.getCode(), msg);
 WebUtils.writeJson(response, resultData);
 }
}

Controller：

1
2
3
4
5
6
7


@GetMapping("/test2")
@Limit(key = "limit2", permitsPerSecond = 1, timeout = 500, 
 timeunit = TimeUnit.MILLISECONDS, msg = "排队中，请稍候")
public String limit2() {
 log.info("limit2 获取令牌成功");
 return "ok";
}

4.5 IP 级限流

思路：每个 IP 一个 RateLimiter，缓存到 LoadingCache。

限流工具类：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


public class RateLimitUtil {
 /** 缓存：1000 个 IP，过期 1 天 */
 private static LoadingCache<String, RateLimiter> limitCaches = CacheBuilder.newBuilder()
 .maximumSize(1000)
 .expireAfterWrite(1, TimeUnit.DAYS)
 .build(new CacheLoader<String, RateLimiter>() {
 @Override
 public RateLimiter load(String key) {
 double perSecond = RateLimitUtil.getCacheKeyPerSecond(key);
 return RateLimiter.create(perSecond);
 }
 });
 
 /** 唯一 key = 资源名:ip:perSecond */
 public static String generateCacheKey(Method method, HttpServletRequest request) {
 RateLimit rateLimit = method.getAnnotation(RateLimit.class);
 StringBuilder cacheKey = new StringBuilder(rateLimit.name() + ":");
 cacheKey.append(getIpAddr(request) + ":");
 cacheKey.append(rateLimit.perSecond());
 return cacheKey.toString();
 }
 
 public static double getCacheKeyPerSecond(String cacheKey) {
 return Double.parseDouble(cacheKey.split(":")[2]);
 }
 
 public static String getIpAddr(HttpServletRequest request) {
 String ip = request.getHeader("x-forwarded-for");
 if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
 ip = request.getHeader("Proxy-Client-IP");
 }
 if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
 ip = request.getRemoteAddr();
 }
 // 多级代理取第一个 IP
 if (ip != null && ip.length() > 15) {
 if (ip.indexOf(",") > 0) {
 ip = ip.substring(0, ip.indexOf(","));
 }
 }
 return ip;
 }
}

五、分布式应用限流（Redis + Lua 令牌桶）

5.1 为什么需要 Redis 限流

Guava RateLimiter 是进程内的，集群部署时每个节点都有一份独立的限流器——比如 3 节点配 100 QPS，实际可能是 300 QPS。

Redis 限流 = 全集群共享一份限流计数。

5.2 令牌桶算法（Lua 实现）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


-- KEYS[1]: 接口唯一 ID
-- ARGV[1]: max_token（桶容量）
-- ARGV[2]: token_rate（每秒产生令牌数）
-- ARGV[3]: current_time（当前时间戳，毫秒）

local ratelimit_info = redis.pcall('HMGET', KEYS[1], 'last_time', 'current_token')
local last_time = ratelimit_info[1]
local current_token = tonumber(ratelimit_info[2])
local max_token = tonumber(ARGV[1])
local token_rate = tonumber(ARGV[2])
local current_time = tonumber(ARGV[3])

if current_token == nil then
 current_token = max_token
 last_time = current_time
else
 local past_time = current_time - last_time
 
 if past_time > 1000 then
 current_token = current_token + token_rate
 last_time = current_time
 end
 
 -- 防止溢出
 if current_token > max_token then
 current_token = max_token
 last_time = current_time
 end
end

local result = 0
if (current_token > 0) then
 result = 1
 current_token = current_token - 1
 last_time = current_time
end

redis.call('HMSET', KEYS[1], 'last_time', last_time, 'current_token', current_token)
return result

关键点：

每个接口的 key（如 uri:/api/order/create）对应一个 Hash
Hash 存 last_time（上次请求时间）+ current_token（当前桶内令牌数）
每隔 1000ms 自动补充 token_rate 个令牌
拿不到令牌返回 0，拿到了返回 1 并减 1

5.3 Spring Boot 集成

Redis 序列化配置：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


@Bean(value = "redisTemplate")
@Primary
public RedisTemplate redisTemplate(RedisConnectionFactory factory) {
 RedisTemplate<String, Object> template = new RedisTemplate<>();
 template.setConnectionFactory(factory);
 
 ObjectMapper objectMapper = new ObjectMapper();
 objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
 
 StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
 Jackson2JsonRedisSerializer jsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
 jsonRedisSerializer.setObjectMapper(objectMapper);
 
 template.setKeySerializer(stringRedisSerializer);
 template.setHashKeySerializer(stringRedisSerializer);
 template.setValueSerializer(jsonRedisSerializer);
 template.setHashValueSerializer(jsonRedisSerializer);
 return template;
}

限流工具类：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


public class RedisLimiterUtils {
 
 private static StringRedisTemplate stringRedisTemplate = 
 ApplicationContextUtils.applicationContext.getBean(StringRedisTemplate.class);
 
 /**
 * 拿令牌
 * @param key 请求 ID（如接口 URI）
 * @param max 桶容量
 * @param rate 每秒生成令牌数
 * @return true=拿到，false=限流
 */
 public static boolean tryAcquire(String key, int max, int rate) {
 List<String> keyList = new ArrayList<>(1);
 keyList.add(key);
 
 DefaultRedisScript<Long> script = new DefaultRedisScript<>();
 script.setResultType(Long.class);
 script.setScriptText(LUA_SCRIPT);
 
 Long result = stringRedisTemplate.execute(
 script, keyList,
 Integer.toString(max),
 Integer.toString(rate),
 Long.toString(System.currentTimeMillis())
 );
 
 return Long.valueOf(1).equals(result);
 }
}

5.4 注解 + 拦截器

注解：

1
2
3
4
5
6
7


@Inherited
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimit {
 int capacity() default 100; // 桶容量
 int rate() default 10; // 每秒令牌数
}

拦截器：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


@Component
public class RateLimiterIntercept implements HandlerInterceptor {
 
 @Override
 public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
 Object handler) throws Exception {
 if (handler instanceof HandlerMethod) {
 HandlerMethod handlerMethod = (HandlerMethod) handler;
 Method method = handlerMethod.getMethod();
 
 RateLimit rateLimit = AnnotationUtils.findAnnotation(method, RateLimit.class);
 if (Objects.isNull(rateLimit)) {
 rateLimit = AnnotationUtils.findAnnotation(
 handlerMethod.getBean().getClass(), RateLimit.class);
 }
 
 if (Objects.isNull(rateLimit)) return true;
 
 // 拿令牌，失败抛异常
 if (!RedisLimiterUtils.tryAcquire(
 request.getRequestURI(),
 rateLimit.capacity(),
 rateLimit.rate())) {
 throw new TimeOutException("系统繁忙，请稍后再试");
 }
 }
 return true;
 }
}

注册拦截器：

1
2
3
4
5
6
7
8


@Configuration
public class WebConfigurer implements WebMvcConfigurer {
 @Override
 public void addInterceptors(InterceptorRegistry registry) {
 registry.addInterceptor(new RateLimiterIntercept())
 .addPathPatterns("/**");
 }
}

六、4 种限流方案对比

维度	Nginx	Tomcat	Guava	Redis + Lua
粒度	IP / Server	容器线程	接口	接口 / 用户 / 全局
作用层	边缘	容器	单体应用	分布式
性能	极高	高	高	中（网络 IO）
跨节点	是	否	否	是
实现成本	配置	配置	引入 + AOP	Lua + 工具类
推荐场景	公网入口	单体应用	单体应用	分布式集群

七、面试常问

Q：令牌桶和漏桶有什么区别？ A：

令牌桶：以恒定速率生产令牌，请求消耗令牌。允许突发流量（桶满时能瞬时处理多个请求）
漏桶：以恒定速率流出请求，水（请求）任意速率流入桶。强制平滑，不允许突发

Q：为什么 Redis 限流要选 Lua 脚本？ A：Redis 单线程 + Lua 原子执行，整个限流判断在一次 RTT 内完成。如果用 Java 代码分多次调用（HMGET → 业务判断 → HMSET），中间被打断会导致计数错乱。

Q：Guava RateLimiter 和 Redis 限流怎么选？ A：

单实例 / 性能敏感：Guava（避免 Redis 网络 IO）
多实例 / 严格全局限流：Redis（保证全集群总和）

Q：Nginx 的 burst 和 nodelay 怎么理解？ A：burst=10 nodelay 表示允许 10 个请求瞬时超出 rate，但立即处理不排队。等价于"令牌桶初始有 10 个令牌，被拿完后必须等下一个令牌生成"。

八、小结

限流分层：CDN → Nginx → Tomcat → Gateway → 单体应用 → 分布式 Redis
Nginx：边缘限流首选，配置简单性能高
Tomcat：maxThreads 调优是基本功
Guava：单体内 AOP + 注解最优雅
Redis + Lua：分布式场景的必选，原子性 + 全局一致

Lua 在 Java 业务系统中的五大实战场景

Sat, 15 Oct 2016 00:00:00 +0800

前置知识

熟悉 Java Web 开发（Spring / Spring Boot 任意版本）
了解 Redis 基本命令
知道 JVM 启动慢、ClassLoader 热加载是什么

为什么要让 Java 跑 Lua

Java 是企业级开发的"压舱石"——生态完善、JVM 稳定、IDE 友好、性能不错。但有三个老大难：

配置改动要重启：上线一个风控规则、走一遍灰度发布、改一个促销门槛——改个 application.yml 就要重新打包发布。
业务规则硬编码：满减、折扣、积分计算写死在 if-else 里，业务方想加一个"双 11 临时活动"得提需求、排期、走发版。
计算密集型任务吃 CPU：复杂业务规则一跑就是几十个 if 嵌套、几万次循环，CPU 飙高时 GC 抖动。

Lua 是这三种痛点的天然解药——脚本解释执行、改完不用重启、几 MB 内存就启动、Redis 直接内置解释器。1993 年问世的小语言，在 2010 年代的"Java 后端 + 性能优化"风潮里重新焕发第二春。

下面是我接触过的 5 个最常见落地场景。

一、动态配置：配置改动"热生效"

1.1 朴素痛点

1
2
3
4
5
6
7
8


// application.yml
risk:
 reject-score: 80

// 业务代码
if (user.getScore() > 80) {
 throw new RiskException("风控拒绝");
}

风控团队说"调成 90"，开发改了 yml，提交 PR → 等 CI → 等发布 → 等滚动重启——半小时过去。

1.2 Lua 化方案

把"判断逻辑"本身写成 Lua 脚本，Java 端只负责"读脚本 + 喂数据 + 拿结果"。

1
2
3
4
5
6
7
8
9


-- risk_rule.lua
-- 输入 ARGV[1] = 用户JSON，ARGV[2] = 阈值
local user = cjson.decode(ARGV[1])
local threshold = tonumber(ARGV[2])

if user.score > threshold then
 return {code = 1, msg = "风控拒绝"}
end
return {code = 0, msg = "通过"}

Java 端用 LuaJ 加载：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


@PostConstruct
public void init() throws IOException {
 // 从 classpath / 配置中心读脚本
 try (InputStream in = new ClassPathResource("risk_rule.lua").getInputStream()) {
 script = StreamUtils.copyToString(in, StandardCharsets.UTF_8);
 }
 // 编译成 Chunk，缓存
 chunk = Globals.load(script, "risk_rule");
}

public RiskResult check(User user) {
 Globals globals = Globals.create();
 LuaValue luaUser = CoerceJavaToLua.coerce(user);
 LuaValue threshold = LuaValue.valueOf(config.getRejectScore());
 LuaValue[] result = chunk.invoke(luaUser, threshold);
 return new RiskResult(result[0].toint(), result[1].tojstring());
}

1.3 热加载实现

脚本放配置中心（Nacos / Apollo），版本号变了就重新 Globals.load：

1
2
3
4
5
6
7
8


@NacosValue(value = "${risk.script.version}", autoRefreshed = true)
private String version;

@NacosConfigListener(dataId = "risk_rule.lua")
public void onScriptChange(String newScript) {
 this.chunk = Globals.load(newScript, "risk_rule");
 log.info("risk script reloaded, version={}", version);
}

效果：风控同学改 Lua 脚本 → 提交配置中心 → Java 端秒级生效。0 重启、0 发布、5 秒生效。

二、规则引擎：业务规则从代码里"剥离"

2.1 痛点

1
2
3
4
5
6
7
8


// 业务方"加一条满 199 减 50"
if (sku.getPrice() >= 199) {
 order.setDiscount(50);
} else if (sku.getPrice() >= 99) {
 order.setDiscount(10);
}
// 一周后又来："双 11 满 199 减 80"
// 一周后又来："VIP 用户满 99 减 30"

if 越堆越多，到最后没人敢动——牵一发动全身。

2.2 Lua 化方案

把规则整体抽到 Lua，业务方"改规则不发版"：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


-- discount.lua
-- inputs: {price, isVip, hasCoupon}
-- outputs: {discount, reason}
local inputs = ...
local price = tonumber(inputs.price) or 0
local isVip = inputs.isVip or false

if price >= 199 and isVip then
 return {discount = 80, reason = "VIP 满 199 减 80"}
elseif price >= 199 then
 return {discount = 50, reason = "满 199 减 50"}
elseif price >= 99 and isVip then
 return {discount = 30, reason = "VIP 满 99 减 30"}
end
return {discount = 0, reason = "无折扣"}

Java 端用 Aviator / Groovy / LuaJ 都能执行——选 Lua 的原因：轻量、嵌入式、独立进程不需要、安全沙箱天然支持（setfenv 限定能调的函数）。

三、插件化开发：业务模块"即插即用"

3.1 痛点

某"行业 SaaS 系统"有 200+ 业务模块（订单、库存、营销、CRM…），每个客户买的功能组合不一样。Java 单体应用里硬塞 200 个 if-else 模块加载？包太大、启动慢、不用的代码也带进 JVM。

3.2 Lua 插件方案

每个功能模块一个 Lua 脚本，Java 端维护"插件注册表"：

1
2
3
4
5
6
7
8


-- plugins/coupon.lua
function handle(context)
 local order = context.order
 if order.amount >= 100 then
 order.discount = 20
 end
 return order
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


public class LuaPluginManager {
 private final Map<String, LuaValue> plugins = new ConcurrentHashMap<>();

 @PostConstruct
 public void loadPlugins() {
 // 从插件目录加载
 for (String name : pluginNames) {
 String code = Files.readString(Path.of("plugins/" + name + ".lua"));
 plugins.put(name, Globals.load(code, name));
 }
 }

 public Object executePlugin(String name, Object context) {
 LuaValue fn = plugins.get(name);
 return fn.call(CoerceJavaToLua.coerce(context)).toJavaObject(Object.class);
 }
}

新增插件 = 新增 .lua 文件 + 重启一次（或热加载），不用动 Java 代码。

四、性能优化：把计算密集型任务"外包"给 Lua

4.1 痛点

JVM 上的复杂业务规则一跑，CPU 就吃满——不是 JVM 不行，而是 Java 本身适合 IO/业务编排，密集循环 不如 C/C++/Lua 这种轻量虚拟机。

4.2 真实案例

某保险定价引擎：每张保单 5 万次循环算精算，Java 跑 200ms 用满 1 个核心。换成 LuaJ：

实现	单次耗时	CPU 占用	内存
Java 朴素版	200ms	100%	1.2GB
LuaJ 优化版	35ms	30%	80MB

秘诀：LuaJ 对纯数值计算做了 JSE 编译优化（luaj-jse），等价于把 Lua 编译成字节码跑在 JVM 上——循环效率接近 C。

1
2
3
4
5


// 启动时编译一次
LuaValue chunk = Globals.load(scriptCode, "pricing");

// 每次计算
double[] result = (double[]) chunk.call(LuaValue.valueOf(age)).toJavaObject(double[].class);

五、Redis 原子操作：Lua 脚本的"杀手锏"

5.1 为什么 Redis 内置 Lua

Redis 是单线程执行命令的——多个命令之间会被其他客户端插入，破坏原子性。Redis 从 2.6 起内置 Lua 解释器，EVAL / EVALSHA 可以让一段 Lua 脚本"原子"地执行 N 个 Redis 命令。

5.2 分布式锁的正确打开方式

1
2
3
4
5
6
7
8


-- unlock.lua
-- KEYS[1] = 锁 key
-- ARGV[1] = 持有者标识（uuid）
if redis.call("get", KEYS[1]) == ARGV[1] then
 return redis.call("del", KEYS[1])
else
 return 0
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// 释放锁
String luaScript =
 "if redis.call('get', KEYS[1]) == ARGV[1] then " +
 " return redis.call('del', KEYS[1']) " +
 "else return 0 end";
Long result = redisTemplate.execute(
 new DefaultRedisScript<>(luaScript, Long.class),
 Collections.singletonList(lockKey),
 lockValue // 必须是当前请求的 uuid
);

为什么不能直接 DEL：客户端 A 加锁 10s，GC 卡了 15s，锁自动释放；客户端 B 加锁成功；A 醒过来直接 DEL——B 的锁被误删。Lua 脚本先 GET 比对 value 再 DEL，避免误删。

5.3 限流：滑动窗口的 Lua 实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


-- rate_limit.lua
-- KEYS[1] = 限流 key
-- ARGV[1] = 窗口大小（毫秒）
-- ARGV[2] = 阈值
-- ARGV[3] = 当前时间戳
local key = KEYS[1]
local window = tonumber(ARGV[1])
local limit = tonumber(ARGV[2])
local now = tonumber(ARGV[3])

redis.call("zremrangebyscore", key, 0, now - window)
local count = redis.call("zcard", key)
if count < limit then
 redis.call("zadd", key, now, now .. ":" .. math.random())
 redis.call("expire", key, math.ceil(window / 1000))
 return 1 -- 允许
end
return 0 -- 拒绝

1
2
3
4
5
6
7
8


// Spring Data Redis
DefaultRedisScript<Long> script = new DefaultRedisScript<>(luaScript, Long.class);
Long allowed = redisTemplate.execute(script,
 Collections.singletonList("rate:user:" + userId),
 60000, // 60s 窗口
 100, // 100 次
 String.valueOf(System.currentTimeMillis())
);

整个限流判断在 Redis 单线程内完成，纯原子——多客户端并发也不会超卖。

5.4 黑名单判定

1
2
3
4


-- blacklist.lua
-- KEYS[1] = 黑名单 set key
-- ARGV[1] = 待查用户 id
return redis.call("sismember", KEYS[1], ARGV[1])

用 SISMEMBER 一行就够——但和"扣库存 + 写订单 + 减库存"组合时，必须 Lua 原子化。

六、落地建议

场景	推荐方案	注意事项
动态配置	LuaJ / Groovy + 配置中心	沙箱限定能调的 Java API
规则引擎	Aviator / LuaJ / QLExpress	性能要求高用 Lua、表达式简单用 Aviator
插件化	自研 Lua 插件管理器	插件版本管理、依赖隔离
计算密集	LuaJ JSE 模式	跨语言调用数据序列化开销别忽视
Redis 原子	EVAL / EVALSHA	脚本里不要用 `KEYS *` 扫全库

七、下一步

沙箱安全：setfenv 限定能调的全局函数，防止恶意脚本 os.execute 删库
可视化编辑：业务方不懂 Lua？做个 Web 编辑器（Monaco Editor + 简单语法校验）
监控：脚本执行时间 P99 报警、错误率统计
IDE 插件：VSCode + Lua Language Server 给业务方写脚本

参考资料

Roberto Ierusalimschy. Programming in Lua（第 3 版）
Redis 官方文档 - Scripting：https://redis.io/docs/interact/programmability/eval-intro/
LuaJ 文档：https://luaj.sourceforge.net/
Spring Data Redis 脚本执行：https://docs.spring.io/spring-data/redis/docs/current/reference/html/#scripting

2024+ 视角：Lua 5.4 / LuaJIT 与 WASM 时代的 Lua

Lua 5.4（2020-06 GA）核心变化

新一代 GC：分代 GC（Generational GC）— 短命对象回收更快
const 变量：local const x <const> = 10 编译期常量
<close> 变量：自动关闭资源（文件、网络、数据库连接）
<toclose> 修饰：local file <close> = io.open(...) 出作用域自动 close

1
2
3
4
5
6


-- Lua 5.4 新特性
local function readConfig()
 local file <close> = assert(io.open("config.lua", "r"))
 return file:read("*a")
end
-- 函数结束，file 自动关闭（即使中间抛错）

整数 / 浮点分离：默认 integer 子类型，跨平台一致
弃用 goto 标签限制：允许在 goto 跳过变量声明

LuaJIT 2.1 现状

LuaJIT 仍是性能 SOTA——Lua 5.4 标准实现比 LuaJIT 慢 5-10 倍：

LuaJIT 2.1 beta（Mike Pall 仍在维护）：追踪式 JIT，对数值计算 / 字符串处理极快
Lua 5.4 兼容性：LuaJIT 仍是 5.1 兼容 + 部分 5.2/5.3 特性
LuaJIT FFI：直接调 C 函数，比标准 Lua/C API 简单

1
2
3
4
5
6


-- LuaJIT FFI 调 C 标准库
local ffi = require("ffi")
ffi.cdef[[
 int printf(const char *fmt, ...);
]]
ffi.C.printf("Hello from C!\n")

Redis 7.x 时代的 Lua 脚本

Redis 7.0+ 引入 Functions 机制——替代 EVAL/EVALSHA 的"长期"脚本：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


-- myrate_limit.lua
-- KEYS[1] = 限流 key
-- ARGV[1] = 阈值
-- ARGV[2] = 窗口毫秒
local key = KEYS[1]
local limit = tonumber(ARGV[1])
local window = tonumber(ARGV[2])
local now = tonumber(ARGV[3])

redis.call("zremrangebyscore", key, 0, now - window)
local count = redis.call("zcard", key)
if count < limit then
 redis.call("zadd", key, now, now .. ":" .. math.random())
 redis.call("expire", key, math.ceil(window / 1000))
 return 1
end
return 0

1
2
3
4
5
6
7


# 上传到 Redis
redis-cli -h 127.0.0.1 -p 6379 \
 FUNCTION LOAD LUA "$./myrate_limit.lua" REPLACE

# 调用
redis-cli -h 127.0.0.1 -p 6379 \
 FUNCTION CALL ratelimit_user_123 100 60000

优势：

脚本作为命名函数注册，不再需要 EVALSHA 哈希
函数库可持久化（写到 RDB）
集群模式下自动路由（FUNCTION LOAD 一次）
替代过去的脚本缓存管理

Redis 8.0（2025）核心变化

向量搜索（GA）：FT.SEARCH 配合 HNSW / FLAT 索引
JSON 数据类型（增强）：JSON.GET / JSON.SET 原生 JSON 支持
Time Series 改进：跨时区、压缩比 +20%
多线程 IO：单实例 100w+ QPS（Lua 脚本仍是单线程）

OpenResty 2024+ 现状

OpenResty = Nginx + LuaJIT——仍是 API 网关 / WAF 首选：

OpenResty 1.25+（2024）：Nginx 1.25 内核 + LuaJIT 2.1
apisix（Apache 顶级项目）：OpenResty 写的 API 网关，2024+ 主流
Kong 3.x：OpenResty 写，插件生态最丰富

规则引擎的 2024+ 现状

Java 生态规则引擎对比：

引擎	语言	2024+ 状态
Drools	Java	老牌但维护慢
Aviator	Java	表达式求值，5.x 活跃
easy-rules	Java	简单规则首选
QLExpress	Java	阿里系
groovy	JVM	动态规则
LuaJ	Lua	性能 + 沙箱优势仍在
GraalVM Polyglot	多语言	2024+ 新选择

GraalVM Polyglot 2024+ 实践

GraalVM 让你在 Java 里直接跑 Lua 脚本——免 LuaJ 依赖：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


import org.graalvm.polyglot.Context;
import org.graalvm.polyglot.Value;

try (Context context = Context.newBuilder("lua")
 .allowAllAccess(true)
 .build()) {

 Value result = context.eval("lua",
 "local x = 10\n" +
 "local y = 20\n" +
 "return x + y");

 System.out.println("结果: " + result.asInt()); // 30
}

优势：

多语言支持（Lua / JS / Python / Ruby / R）
与 Java 互操作简单
Truffle 框架优化性能
比 LuaJ 启动快、跨平台一致

Lua 在云原生时代的定位

1
2
3
4
5
6
7


场景 推荐
─────────────────────────────────
Redis 原子脚本 Lua 5.1 + Redis Functions
Nginx 网关/WAF OpenResty + LuaJIT
游戏服务端 LuaJIT 仍是 SOTA
配置中心规则 LuaJ / GraalVM Polyglot
边缘计算 不再推荐（被 WASM 取代）

WASM 时代：Lua 还在吗？

wasm-lua / wasmoon：把 Lua 编译成 WASM 模块
QuickJS + WASI：JS 在边缘计算更主流
Lua 5.4 + WASM：实验阶段，性能比 LuaJIT 差

结论：WASM 时代 Lua 优势减弱，但 Redis / OpenResty 生态仍是 Lua 主场。

2024+ 实战建议

Redis 脚本：用 Functions（Redis 7+）替代 EVAL/EVALSHA
网关层：OpenResty + LuaJIT 仍是高性能首选
规则引擎：复杂规则用 LuaJ 或 Drools，简单表达式用 Aviator
多语言嵌入：GraalVM Polyglot 是 2024+ 的现代选择
性能敏感：LuaJIT 2.1 仍是 SOTA（5-10 倍于标准 Lua 5.4）

2024+ 推荐组合

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


Redis 原子操作
├── Redis 7.x / 8.x
├── Lua 5.1（Redis 内置）
└── Functions 机制（替代 EVAL）

API 网关 / WAF
├── OpenResty 1.25+
├── LuaJIT 2.1
└── apisix / Kong

规则引擎（Java 业务）
├── GraalVM Polyglot + Lua
└── 复杂规则降级 Drools