一、LuaJIT 编译优化：让性能飞起来
OpenResty 的核心优势之一就是内置了 LuaJIT 这个高性能的 Lua 编译器。但很多人不知道的是，默认配置下的 LuaJIT 其实只发挥了 60% 的性能潜力。下面我们来看看如何榨干它的每一分性能。
首先，我们需要理解 LuaJIT 的工作模式。它有两种运行方式：解释执行和 JIT 编译执行。理想情况下，我们希望热点代码都能被 JIT 编译。来看个实际的例子：
-- 示例：热点函数优化
local function process_item(item)
-- 这个函数会被频繁调用，需要确保被JIT编译
return item.price * item.quantity * (1 - item.discount)
end
-- 告诉LuaJIT这个函数需要被JIT编译
jit.on(process_item, true)
-- 批量处理函数
local function batch_process(items)
local total = 0
for i = 1, #items do
total = total + process_item(items[i])
end
return total
end
这里有几个关键点需要注意：
- 使用
jit.on()显式标记热点函数 - 避免在热点函数中使用无法被 JIT 编译的特性（如某些字符串操作）
- 保持函数参数和返回值类型稳定
在实际项目中，我们可以通过 jit.v 和 jit.dump 模块来检查哪些代码被 JIT 编译了。建议在开发环境加上这个配置：
http {
lua_code_cache on;
init_by_lua_block {
-- 开启JIT编译日志
if os.getenv("OPENRESTY_DEV") then
jit.v = true
jit.dump = true
end
}
}
二、共享内存的艺术：平衡性能与资源
OpenResty 的共享内存（shared_dict）是个强大的特性，但如果使用不当，反而会成为性能瓶颈。我们先看一个典型的共享内存使用场景：
-- 示例：计数器服务
local counter = ngx.shared.request_counter
local function increment_counter(key)
-- 使用原子操作避免竞争
local newval, err = counter:incr(key, 1, 0)
if not newval then
ngx.log(ngx.ERR, "failed to increment counter: ", err)
return nil, err
end
-- 定期同步到外部存储
if newval % 100 == 0 then
local ok, err = save_to_db(key, newval)
if not ok then
ngx.log(ngx.WARN, "failed to sync counter: ", err)
end
end
return newval
end
共享内存使用有几个黄金法则：
- 尽量使用原子操作（incr/add等）
- 避免大value（超过1KB就要考虑拆分）
- 设置合理的过期时间
- 监控内存使用情况
对于大型应用，建议采用分层缓存策略：
-- 示例：分层缓存策略
local function get_cached_data(key)
-- 第一层：worker本地缓存
local data = worker_cache.get(key)
if data then return data end
-- 第二层：共享内存缓存
data = shared_dict.get(key)
if data then
worker_cache.set(key, data)
return data
end
-- 第三层：外部存储
data = fetch_from_backend(key)
if data then
shared_dict.set(key, data, 60) -- 60秒过期
worker_cache.set(key, data)
end
return data
end
三、异步 IO 模型：高并发的秘密武器
OpenResty 的异步非阻塞 IO 模型是其高并发能力的核心。我们先看一个常见的同步阻塞写法：
-- 反例：同步阻塞IO
local function fetch_data_sync(url)
local http = require "resty.http"
local httpc = http.new()
-- 同步请求（会阻塞worker）
local res, err = httpc:request_uri(url)
if not res then
return nil, err
end
return res.body
end
正确的异步写法应该是这样的：
-- 正例：异步非阻塞IO
local function fetch_data_async(url, callback)
local http = require "resty.http"
local httpc = http.new()
-- 异步请求
httpc:connect({
scheme = "https",
host = "api.example.com",
port = 443
}, function(err)
if err then return callback(nil, err) end
httpc:request({
method = "GET",
path = "/data"
}, function(err, res)
if err then return callback(nil, err) end
local body = res:read_body()
callback(body)
end)
end)
end
异步编程有几个关键点：
- 使用 cosocket 而非系统 socket
- 避免在回调中执行耗时操作
- 合理设置超时时间
- 使用连接池复用连接
对于复杂的异步流程控制，可以使用 OpenResty 提供的 ngx.thread 模块：
-- 示例：并行请求
local function fetch_multiple_urls(urls)
local threads = {}
for i, url in ipairs(urls) do
threads[i] = ngx.thread.spawn(function()
return fetch_data_async(url)
end)
end
local results = {}
for i, thread in ipairs(threads) do
results[i] = { ngx.thread.wait(thread) }
end
return results
end
四、实战中的调优策略
在实际项目中，我们需要综合考虑各种因素。这里给出一个完整的性能调优检查清单：
LuaJIT 方面
- 检查 JIT 编译覆盖率
- 避免使用 NYI（Not Yet Implemented）特性
- 合理设置 JIT 参数
共享内存方面
- 监控内存碎片率
- 设置合理的 zone 大小
- 实现 LRU 淘汰策略
异步 IO 方面
- 检查连接池配置
- 监控 pending 请求数
- 优化 DNS 解析
这里有一个完整的 Nginx 配置示例：
http {
# LuaJIT 配置
lua_jit_max_pending_flush 1024;
lua_jit_max_mcode_size 512k;
# 共享内存配置
lua_shared_dict api_cache 100m;
lua_shared_dict locks 10m;
# 异步IO配置
resolver 8.8.8.8 valid=30s;
resolver_timeout 2s;
server {
listen 8080;
location /api {
content_by_lua_block {
-- 这里放置业务逻辑
}
}
}
}
最后，记住性能调优的黄金法则：测量、优化、再测量。OpenResty 提供了丰富的监控接口：
-- 示例：获取运行时状态
local function get_runtime_stats()
return {
memory = ngx.shared.api_cache:get_stats(),
connections = ngx.var.connections_active,
requests = ngx.var.requests,
worker_pid = ngx.worker.pid()
}
end
通过持续监控这些指标，我们可以及时发现性能瓶颈并进行针对性优化。
评论