Lua 并发模型：从协程到多线程的演进与选型

-- 一个 Lua 状态：任意时刻只有一段代码在执行
local co = coroutine.create(function()
    while true do
        coroutine.yield()   -- 主动让出，绝不抢占
    end
end)

-- 协程任务队列 + 简单事件循环
local pending = {}        -- {co = 协程, at = 唤醒时间}

local function spawn(fn)
    local co = coroutine.create(fn)
    table.insert(pending, {co = co, at = os.clock()})
end

local function sleep(seconds)
    coroutine.yield(os.clock() + seconds)   -- 让出，附带回唤醒时间
end

local function run_loop()
    while #pending > 0 do
        local now = os.clock()
        for i = #pending, 1, -1 do
            local p = pending[i]
            if now >= p.at then
                local ok, err = coroutine.resume(p.co)
                if not ok then
                    print("协程错误: " .. tostring(err))
                    table.remove(pending, i)
                elseif coroutine.status(p.co) == "dead" then
                    table.remove(pending, i)
                else
                    p.at = err  -- 协程让出时带回下次唤醒时间
                end
            end
        end
    end
end

spawn(function()
    for i = 1, 3 do
        print("任务A 第" .. i .. "步")
        sleep(0.1)
    end
end)
run_loop()

-- 方式一：显式非阻塞 + select 轮询（LuaSocket）
local socket = require("socket")
local client = socket.connect("127.0.0.1", 80)
client:settimeout(0)                 -- 非阻塞模式

while true do
    local chunk, err = client:receive(1)
    if chunk then
        -- 读到数据
    elseif err == "timeout" then
        -- 未就绪，让出时间片
        coroutine.yield()
    else
        break
    end
end

-- 方式二：协程自动让出（OpenResty cosocket）
-- 开发者写同步风格代码，底层在 IO 未就绪时自动 yield
local http = require("resty.http")
local res = httpc:request_uri("http://upstream/api")  -- 内部自动让出

         ┌──────── 请求入口 ────────┐
         ▼                         ▼
   worker 0（Lua 状态）       worker N（Lua 状态）
   事件循环 + 协程池           事件循环 + 协程池
         │                         │
         └────── 共享外部存储 ──────┘
             Redis / 消息队列 / 共享内存

-- worker 内的共享状态全部走 Redis，天然跨进程一致
local redis = require("resty.redis")
local red = redis:new()
red:connect("127.0.0.1", 6379)

-- 原子自增：防止两个 worker 同时写坏计数器
local n = red:incr("visits")
red:expire("visits", 3600)

-- 入口处按用户 ID 哈希选 worker
local workers = {"worker_a", "worker_b", "worker_c"}
local idx = (crc32(uid) % #workers) + 1
local target = workers[idx]

local lanes = require("lanes").configure()

-- 把 CPU 密集的哈希计算丢给线程池
local gen = lanes.gen("*", function(block)
    return sha256_impl(block)   -- 纯函数，无共享状态
end)

-- 协程侧照常处理请求
local function handler(payload)
    local digest = gen(payload)          -- 阻塞等待线程结果
    local ok, err = persist(digest)      -- IO 让出，不占线程
    return ok
end

local lanes = require("lanes").configure()
local linda = lanes.linda()

-- 在另一个线程里执行
local function worker(input)
    local sum = 0
    for i = 1, input do sum = sum + i end
    return sum
end

local gen = lanes.gen("*", worker)   -- * 表示任意线程池
local handle = gen(1000000)

local result = handle:join()         -- 阻塞等待结果
print("结果:", result)

-- 用 linda 做任务队列：主线程派发，worker 线程消费
local linda = lanes.linda()

lanes.gen("*", function()
    while true do
        local job = linda:receive("job", 1)   -- 1 秒超时
        if job then
            local ok, err = process(job)
            linda:send("result", job.id, ok, err)
        end
    end
end)()

for _, job in ipairs(jobs) do
    linda:send("job", job)
end

local luaproc = require("luaproc")

-- 启动一个 Luaproc 进程
luaproc.newproc([[
    local luaproc = require("luaproc")
    while true do
        local msg = luaproc.receive()         -- 阻塞接收
        if msg == "ping" then
            luaproc.send("pong")
        elseif msg == "quit" then
            break
        end
    end
]])

luaproc.send("ping")
print(luaproc.receive())    -- pong
luaproc.send("quit")

/* C 宿主：每个工作线程持有一个独立 lua_State */
void *worker(void *arg) {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);
    while (1) {
        /* 从队列取任务，调用 Lua 函数处理 */
        lua_getglobal(L, "handle_job");
        lua_pushinteger(L, job_id);
        if (lua_pcall(L, 1, 0, 0) != LUA_OK) {
            fprintf(stderr, "%s\n", lua_tostring(L, -1));
            lua_pop(L, 1);
        }
    }
}

-- Lua 侧只需要暴露一个纯函数，交给 C 线程调度
function handle_job(job_id)
    local data = load_from_cache(job_id)
    if data then
        return transform(data)
    end
    return nil, "not found"
end