深入探索Lua多线程编程从基础概念到实际应用中的性能优化与常见陷阱规避

引言：Lua与多线程的不解之缘

Lua作为一种轻量级、高效的脚本语言，以其极佳的嵌入性和灵活性在游戏开发、嵌入式系统和网络服务中广泛应用。然而，Lua语言本身的设计哲学是单线程的，其核心解释器并不是线程安全的。这意味着在原生Lua中直接使用多线程会导致严重的问题。但这并不意味着Lua无法进行多线程编程。通过LuaJIT的扩展、外部库（如Lua Lanes）或与宿主语言（如C/C++）的结合，我们可以实现强大的并发处理能力。本文将深入探讨Lua多线程编程的基础概念、实现方式、性能优化策略以及常见陷阱的规避方法。

一、Lua多线程编程的基础概念

1.1 Lua的单线程本质与并发需求

Lua的核心解释器（State）不是线程安全的。这意味着在多个线程中同时访问同一个Lua状态（lua_State）会导致数据竞争和未定义行为。因此，Lua的多线程编程通常采用以下几种模式：

多状态（Multi-State）模式：每个线程拥有独立的Lua状态，通过消息传递进行通信。
宿主多线程：在宿主语言（如C/C++）中创建多线程，每个线程运行一个独立的Lua状态。
LuaJIT的协程与FFI：利用LuaJIT的协程和FFI（外部函数接口）实现轻量级并发。

1.2 线程与协程的区别

在深入多线程之前，必须明确Lua中协程（Coroutine）与操作系统线程（Thread）的区别：

协程：是协作式多任务，由程序员显式调度，共享同一个Lua状态，适合I/O密集型任务。
线程：是抢占式多任务，由操作系统调度，拥有独立的内存空间，适合CPU密集型任务。

Lua原生支持协程，但多线程需要借助外部工具。

二、Lua多线程的实现方式

2.1 使用Lua Lanes实现多线程

Lua Lanes是一个流行的Lua多线程库，它允许在独立的Lua状态中运行代码，并通过通道（Channel）进行通信。

2.1.1 安装与配置

首先，需要安装Lua Lanes。可以通过LuaRocks安装：

luarocks install lanes

2.1.2 基本使用示例

以下是一个简单的示例，展示如何使用Lua Lanes创建两个线程并传递消息：

local lanes = require("lanes").configure() -- 定义一个简单的任务函数 local function worker(id) print("Worker " .. id .. " started") for i = 1, 5 do print("Worker " .. id .. " processing " .. i) -- 模拟工作负载 os.execute("sleep 1") end return "Worker " .. id .. " done" end -- 创建两个线程 local h1 = lanes.gen("string", worker)(1) local h2 = lanes.gen("string", worker)(2) -- 等待线程完成并获取结果 local result1 = h1[1] local result2 = h2[1] print("Result 1: " .. result1) print("Result 2: " .. result2)

代码解析：

lanes.configure()：初始化Lanes库。
lanes.gen("string", worker)：生成一个新线程，指定返回值类型为字符串。
h1[1]：阻塞等待线程完成并获取结果。

2.1.3 使用通道进行通信

Lua Lanes提供了通道（Channel）用于线程间通信：

local lanes = require("lanes").configure() -- 创建一个通道 local channel = lanes.channel("my_channel") -- 生产者线程 local producer = lanes.gen("any", function() for i = 1, 5 do channel:send("Data " .. i) print("Sent: Data " .. i) os.execute("sleep 1") end channel:send(nil) -- 发送结束信号 end) -- 消费者线程 local consumer = lanes.gen("any", function() while true do local data = channel:receive() if data == nil then break end print("Received: " .. data) end end) -- 启动线程 producer() consumer() -- 等待所有线程完成 lanes.timer(2):join() -- 等待2秒

2.2 宿主多线程：C/C++与Lua结合

在C/C++中创建多线程，每个线程运行一个独立的Lua状态，是另一种常见方式。

2.2.1 C代码示例

以下是一个简单的C程序，创建两个线程，每个线程运行一个Lua脚本：

#include <stdio.h> #include <pthread.h> #include <lua.h> #include <lauxlib.h> #include <lualib.h> // 线程函数 void* thread_func(void* arg) { const char* script = (const char*)arg; lua_State* L = luaL_newstate(); luaL_openlibs(L); if (luaL_dofile(L, script) != LUA_OK) { fprintf(stderr, "Error: %sn", lua_tostring(L, -1)); } lua_close(L); return NULL; } int main() { pthread_t t1, t2; // 创建两个线程 pthread_create(&t1, NULL, thread_func, "script1.lua"); pthread_create(&t2, NULL, thread_func, "script2.lua"); // 等待线程结束 pthread_join(t1, NULL); pthread_join(t2, NULL); return 0; }

2.2.2 Lua脚本示例（script1.lua）

print("Script 1 running in thread") for i = 1, 5 do print("Script 1: " .. i) os.execute("sleep 1") end

2.3 LuaJIT的协程与FFI

LuaJIT的协程可以模拟多线程行为，结合FFI可以调用C库实现高性能并发。

2.3.1 协程示例

local function task(id) for i = 1, 5 do print("Task " .. id .. ": " .. i) coroutine.yield() end end local co1 = coroutine.create(function() task(1) end) local co2 = coroutine.create(function() task(2) end) while coroutine.status(co1) ~= "dead" or coroutine.status(co2) ~= "dead" do coroutine.resume(co1) coroutine.resume(co2) end

2.3.2 FFI多线程示例

LuaJIT的FFI可以调用C的线程库：

local ffi = require("ffi") ffi.cdef[[ typedef void* pthread_t; int pthread_create(pthread_t *thread, const void *attr, void *(*start_routine) (void *), void *arg); int pthread_join(pthread_t thread, void **retval); ]] -- 简单的C函数包装 local function c_thread_func(arg) -- 这里可以调用C库函数 print("C thread running with arg: " .. tostring(arg)) return nil end -- 创建线程（简化示例，实际需要更复杂的C包装） -- 注意：直接使用FFI创建线程需要谨慎，因为LuaJIT的GC与C线程交互复杂

三、性能优化策略

3.1 减少线程创建开销

线程创建和销毁是昂贵的操作。在Lua中，使用线程池可以显著提高性能。

3.1.1 线程池实现示例

local lanes = require("lanes").configure() local ThreadPool = {} ThreadPool.__index = ThreadPool function ThreadPool.new(size) local self = setmetatable({}, ThreadPool) self.tasks = lanes.channel("tasks") self.workers = {} for i = 1, size do local worker = lanes.gen("any", function() while true do local task = self.tasks:receive() if task == nil then break end task.func(table.unpack(task.args)) end end) table.insert(self.workers, worker()) end return self end function ThreadPool:enqueue(func, ...) self.tasks:send({ func = func, args = {...} }) end function ThreadPool:shutdown() for i = 1, #self.workers do self.tasks:send(nil) end end -- 使用示例 local pool = ThreadPool.new(4) for i = 1, 10 do pool:enqueue(function(id) print("Processing task " .. id) os.execute("sleep 1") end, i) end pool:shutdown()

3.2 优化数据传输

在多线程中，数据传输是性能瓶颈。应尽量减少数据复制，使用共享内存或引用传递。

3.2.1 使用共享内存

在C/C++中，可以使用共享内存区域，通过Lua Lanes的共享数据功能：

local lanes = require("lanes").configure() -- 共享数据表 local shared_data = { counter = 0 } -- 互斥锁 local lock = lanes.lock() local function increment() lock:lock() shared_data.counter = shared_data.counter + 1 lock:unlock() end local threads = {} for i = 1, 100 do threads[i] = lanes.gen("any", increment)() end for i = 1, 100 do threads[i]:join() end print("Final counter: " .. shared_data.counter)

3.3 负载均衡

确保任务均匀分配到各个线程，避免某些线程过载。

3.3.1 动态任务分配

local lanes = require("lanes").configure() local function dynamic_scheduler(tasks) local channels = {} for i = 1, 4 do channels[i] = lanes.channel("worker_" .. i) end -- 启动工作线程 for i = 1, 4 do lanes.gen("any", function() while true do local task = channels[i]:receive() if task == nil then break end task() end end)() end -- 动态分配任务 for i, task in ipairs(tasks) do local min_load = math.huge local best_channel = 1 for j = 1, 4 do -- 这里简化，实际应查询通道负载 if #channels[j] < min_load then min_load = #channels[j] best_channel = j end end channels[best_channel]:send(task) end -- 发送结束信号 for i = 1, 4 do channels[i]:send(nil) end end -- 使用示例 local tasks = {} for i = 1, 20 do tasks[i] = function() print("Task " .. i); os.execute("sleep 0.5") end end dynamic_scheduler(tasks)

四、常见陷阱与规避方法

4.1 数据竞争与竞态条件

问题：多个线程同时访问和修改共享数据。

解决方案：

使用互斥锁（Mutex）或信号量。
避免共享可变状态，使用消息传递。

4.1.1 互斥锁示例

local lanes = require("lanes").configure() local counter = 0 local lock = lanes.lock() local function safe_increment() lock:lock() counter = counter + 1 lock:unlock() end local threads = {} for i = 1, 1000 do threads[i] = lanes.gen("any", safe_increment)() end for i = 1, 1000 do threads[i]:join() end print("Counter: " .. counter) -- 应为1000

4.2 死锁

问题：线程相互等待对方释放锁，导致程序挂起。

解决方案：

按固定顺序获取锁。
使用超时机制。

4.2.1 超时锁示例

local lanes = require("lanes").configure() local lock1 = lanes.lock() local lock2 = lanes.lock() local function thread1() if lock1:lock(1) then -- 1秒超时 print("Thread1 got lock1") os.execute("sleep 1") if lock2:lock(1) then print("Thread1 got lock2") lock2:unlock() else print("Thread1 failed to get lock2") end lock1:unlock() else print("Thread1 failed to get lock1") end end local function thread2() if lock2:lock(1) then print("Thread2 got lock2") os.execute("sleep 1") if lock1:lock(1) then print("Thread2 got lock1") lock1:unlock() else print("Thread2 failed to get lock1") end lock2:unlock() else print("Thread2 failed to get lock2") end end lanes.gen("any", thread1)() lanes.gen("any", thread2)()

4.3 内存泄漏

问题：Lua状态或线程资源未正确释放。

解决方案：

确保所有线程在完成后正确关闭。
使用finally模式或pcall确保资源释放。

4.3.1 资源管理示例

local lanes = require("lanes").configure() local function safe_task() local success, err = pcall(function() -- 任务代码 print("Task running") error("Simulated error") -- 模拟错误 end) if not success then print("Task failed: " .. tostring(err)) end -- 资源清理代码在这里执行 print("Resource cleaned up") end lanes.gen("any", safe_task)():join()

4.4 线程安全与Lua状态

问题：在多个线程中共享同一个Lua状态。

解决方案：

每个线程使用独立的Lua状态。
避免在Lua状态间直接传递复杂对象。

4.4.1 独立状态示例

-- 正确做法：每个线程独立状态 local lanes = require("lanes").configure() local function worker() local L = luaL_newstate() luaL_openlibs(L) -- 在独立状态中执行代码 luaL_dostring(L, "print('Hello from independent state')") lua_close(L) end lanes.gen("any", worker)():join()

4.5 性能瓶颈

问题：线程间通信开销过大。

解决方案：

批量处理任务。
减少锁的持有时间。

4.5.1 批量处理示例

local lanes = require("lanes").configure() local channel = lanes.channel("batch") local producer = lanes.gen("any", function() local batch = {} for i = 1, 100 do table.insert(batch, "Data " .. i) if #batch >= 10 then channel:send(batch) batch = {} end end if #batch > 0 then channel:send(batch) end channel:send(nil) end) local consumer = lanes.gen("any", function() while true do local batch = channel:receive() if batch == nil then break end for _, data in ipairs(batch) do print("Processing: " .. data) end end end) producer() consumer()

五、实际应用案例

5.1 高并发网络服务器

在游戏服务器或Web服务器中，使用Lua多线程处理并发连接。

5.1.1 简化模型

local lanes = require("lanes").configure() local function handle_connection(conn) -- 处理连接 print("Handling connection from " .. conn.peer) conn:send("Hello from Lua threadn") conn:close() end local server = lanes.gen("any", function() -- 模拟监听 for i = 1, 10 do local conn = { peer = "client_" .. i } lanes.gen("any", handle_connection)(conn) end end) server():join()

5.2 数据并行处理

在科学计算或数据处理中，使用多线程并行处理数据块。

5.2.1 数据分块处理

local lanes = require("lanes").configure() local function process_chunk(chunk) local result = {} for _, value in ipairs(chunk) do table.insert(result, value * 2) -- 示例处理 end return result end local data = {1,2,3,4,5,6,7,8,9,10} local chunk_size = 2 local chunks = {} for i = 1, #data, chunk_size do local chunk = {} for j = i, math.min(i+chunk_size-1, #data) do table.insert(chunk, data[j]) end table.insert(chunks, chunk) end local results = {} for i, chunk in ipairs(chunks) do local h = lanes.gen("table", process_chunk)(chunk) table.insert(results, h) end for i, h in ipairs(results) do local result = h[1] print("Chunk " .. i .. " result: " .. table.concat(result, ", ")) end

六、总结

Lua多线程编程虽然需要借助外部工具，但通过合理的设计和优化，可以显著提升应用程序的性能。关键点包括：

选择合适的实现方式：根据需求选择Lua Lanes、宿主多线程或LuaJIT FFI。
避免共享状态：优先使用消息传递，减少锁的使用。
优化性能：使用线程池、批量处理和负载均衡。
规避陷阱：注意数据竞争、死锁和内存泄漏。

通过本文的详细讲解和示例，您应该能够掌握Lua多线程编程的核心技术，并在实际项目中应用这些知识来构建高效、稳定的并发系统。# 深入探索Lua多线程编程从基础概念到实际应用中的性能优化与常见陷阱规避

引言：Lua与多线程的不解之缘

一、Lua多线程编程的基础概念

1.1 Lua的单线程本质与并发需求

多状态（Multi-State）模式：每个线程拥有独立的Lua状态，通过消息传递进行通信。
宿主多线程：在宿主语言（如C/C++）中创建多线程，每个线程运行一个独立的Lua状态。
LuaJIT的协程与FFI：利用LuaJIT的协程和FFI（外部函数接口）实现轻量级并发。

1.2 线程与协程的区别

在深入多线程之前，必须明确Lua中协程（Coroutine）与操作系统线程（Thread）的区别：

协程：是协作式多任务，由程序员显式调度，共享同一个Lua状态，适合I/O密集型任务。
线程：是抢占式多任务，由操作系统调度，拥有独立的内存空间，适合CPU密集型任务。

Lua原生支持协程，但多线程需要借助外部工具。

二、Lua多线程的实现方式

2.1 使用Lua Lanes实现多线程

Lua Lanes是一个流行的Lua多线程库，它允许在独立的Lua状态中运行代码，并通过通道（Channel）进行通信。

2.1.1 安装与配置

首先，需要安装Lua Lanes。可以通过LuaRocks安装：

luarocks install lanes

2.1.2 基本使用示例

以下是一个简单的示例，展示如何使用Lua Lanes创建两个线程并传递消息：

local lanes = require("lanes").configure() -- 定义一个简单的任务函数 local function worker(id) print("Worker " .. id .. " started") for i = 1, 5 do print("Worker " .. id .. " processing " .. i) -- 模拟工作负载 os.execute("sleep 1") end return "Worker " .. id .. " done" end -- 创建两个线程 local h1 = lanes.gen("string", worker)(1) local h2 = lanes.gen("string", worker)(2) -- 等待线程完成并获取结果 local result1 = h1[1] local result2 = h2[1] print("Result 1: " .. result1) print("Result 2: " .. result2)

代码解析：

lanes.configure()：初始化Lanes库。
lanes.gen("string", worker)：生成一个新线程，指定返回值类型为字符串。
h1[1]：阻塞等待线程完成并获取结果。

2.1.3 使用通道进行通信

Lua Lanes提供了通道（Channel）用于线程间通信：

local lanes = require("lanes").configure() -- 创建一个通道 local channel = lanes.channel("my_channel") -- 生产者线程 local producer = lanes.gen("any", function() for i = 1, 5 do channel:send("Data " .. i) print("Sent: Data " .. i) os.execute("sleep 1") end channel:send(nil) -- 发送结束信号 end) -- 消费者线程 local consumer = lanes.gen("any", function() while true do local data = channel:receive() if data == nil then break end print("Received: " .. data) end end) -- 启动线程 producer() consumer() -- 等待所有线程完成 lanes.timer(2):join() -- 等待2秒

2.2 宿主多线程：C/C++与Lua结合

在C/C++中创建多线程，每个线程运行一个独立的Lua状态，是另一种常见方式。

2.2.1 C代码示例

以下是一个简单的C程序，创建两个线程，每个线程运行一个Lua脚本：

#include <stdio.h> #include <pthread.h> #include <lua.h> #include <lauxlib.h> #include <lualib.h> // 线程函数 void* thread_func(void* arg) { const char* script = (const char*)arg; lua_State* L = luaL_newstate(); luaL_openlibs(L); if (luaL_dofile(L, script) != LUA_OK) { fprintf(stderr, "Error: %sn", lua_tostring(L, -1)); } lua_close(L); return NULL; } int main() { pthread_t t1, t2; // 创建两个线程 pthread_create(&t1, NULL, thread_func, "script1.lua"); pthread_create(&t2, NULL, thread_func, "script2.lua"); // 等待线程结束 pthread_join(t1, NULL); pthread_join(t2, NULL); return 0; }

2.2.2 Lua脚本示例（script1.lua）

print("Script 1 running in thread") for i = 1, 5 do print("Script 1: " .. i) os.execute("sleep 1") end

2.3 LuaJIT的协程与FFI

LuaJIT的协程可以模拟多线程行为，结合FFI可以调用C库实现高性能并发。

2.3.1 协程示例

local function task(id) for i = 1, 5 do print("Task " .. id .. ": " .. i) coroutine.yield() end end local co1 = coroutine.create(function() task(1) end) local co2 = coroutine.create(function() task(2) end) while coroutine.status(co1) ~= "dead" or coroutine.status(co2) ~= "dead" do coroutine.resume(co1) coroutine.resume(co2) end

2.3.2 FFI多线程示例

LuaJIT的FFI可以调用C的线程库：

local ffi = require("ffi") ffi.cdef[[ typedef void* pthread_t; int pthread_create(pthread_t *thread, const void *attr, void *(*start_routine) (void *), void *arg); int pthread_join(pthread_t thread, void **retval); ]] -- 简单的C函数包装 local function c_thread_func(arg) -- 这里可以调用C库函数 print("C thread running with arg: " .. tostring(arg)) return nil end -- 创建线程（简化示例，实际需要更复杂的C包装） -- 注意：直接使用FFI创建线程需要谨慎，因为LuaJIT的GC与C线程交互复杂

三、性能优化策略

3.1 减少线程创建开销

线程创建和销毁是昂贵的操作。在Lua中，使用线程池可以显著提高性能。

3.1.1 线程池实现示例

local lanes = require("lanes").configure() local ThreadPool = {} ThreadPool.__index = ThreadPool function ThreadPool.new(size) local self = setmetatable({}, ThreadPool) self.tasks = lanes.channel("tasks") self.workers = {} for i = 1, size do local worker = lanes.gen("any", function() while true do local task = self.tasks:receive() if task == nil then break end task.func(table.unpack(task.args)) end end) table.insert(self.workers, worker()) end return self end function ThreadPool:enqueue(func, ...) self.tasks:send({ func = func, args = {...} }) end function ThreadPool:shutdown() for i = 1, #self.workers do self.tasks:send(nil) end end -- 使用示例 local pool = ThreadPool.new(4) for i = 1, 10 do pool:enqueue(function(id) print("Processing task " .. id) os.execute("sleep 1") end, i) end pool:shutdown()

3.2 优化数据传输

在多线程中，数据传输是性能瓶颈。应尽量减少数据复制，使用共享内存或引用传递。

3.2.1 使用共享内存

在C/C++中，可以使用共享内存区域，通过Lua Lanes的共享数据功能：

local lanes = require("lanes").configure() -- 共享数据表 local shared_data = { counter = 0 } -- 互斥锁 local lock = lanes.lock() local function increment() lock:lock() shared_data.counter = shared_data.counter + 1 lock:unlock() end local threads = {} for i = 1, 100 do threads[i] = lanes.gen("any", increment)() end for i = 1, 100 do threads[i]:join() end print("Final counter: " .. shared_data.counter)

3.3 负载均衡

确保任务均匀分配到各个线程，避免某些线程过载。

3.3.1 动态任务分配

local lanes = require("lanes").configure() local function dynamic_scheduler(tasks) local channels = {} for i = 1, 4 do channels[i] = lanes.channel("worker_" .. i) end -- 启动工作线程 for i = 1, 4 do lanes.gen("any", function() while true do local task = channels[i]:receive() if task == nil then break end task() end end)() end -- 动态分配任务 for i, task in ipairs(tasks) do local min_load = math.huge local best_channel = 1 for j = 1, 4 do -- 这里简化，实际应查询通道负载 if #channels[j] < min_load then min_load = #channels[j] best_channel = j end end channels[best_channel]:send(task) end -- 发送结束信号 for i = 1, 4 do channels[i]:send(nil) end end -- 使用示例 local tasks = {} for i = 1, 20 do tasks[i] = function() print("Task " .. i); os.execute("sleep 0.5") end end dynamic_scheduler(tasks)

四、常见陷阱与规避方法

4.1 数据竞争与竞态条件

问题：多个线程同时访问和修改共享数据。

解决方案：

使用互斥锁（Mutex）或信号量。
避免共享可变状态，使用消息传递。

4.1.1 互斥锁示例

local lanes = require("lanes").configure() local counter = 0 local lock = lanes.lock() local function safe_increment() lock:lock() counter = counter + 1 lock:unlock() end local threads = {} for i = 1, 1000 do threads[i] = lanes.gen("any", safe_increment)() end for i = 1, 1000 do threads[i]:join() end print("Counter: " .. counter) -- 应为1000

4.2 死锁

问题：线程相互等待对方释放锁，导致程序挂起。

解决方案：

按固定顺序获取锁。
使用超时机制。

4.2.1 超时锁示例

local lanes = require("lanes").configure() local lock1 = lanes.lock() local lock2 = lanes.lock() local function thread1() if lock1:lock(1) then -- 1秒超时 print("Thread1 got lock1") os.execute("sleep 1") if lock2:lock(1) then print("Thread1 got lock2") lock2:unlock() else print("Thread1 failed to get lock2") end lock1:unlock() else print("Thread1 failed to get lock1") end end local function thread2() if lock2:lock(1) then print("Thread2 got lock2") os.execute("sleep 1") if lock1:lock(1) then print("Thread2 got lock1") lock1:unlock() else print("Thread2 failed to get lock1") end lock2:unlock() else print("Thread2 failed to get lock2") end end lanes.gen("any", thread1)() lanes.gen("any", thread2)()

4.3 内存泄漏

问题：Lua状态或线程资源未正确释放。

解决方案：

确保所有线程在完成后正确关闭。
使用finally模式或pcall确保资源释放。

4.3.1 资源管理示例

local lanes = require("lanes").configure() local function safe_task() local success, err = pcall(function() -- 任务代码 print("Task running") error("Simulated error") -- 模拟错误 end) if not success then print("Task failed: " .. tostring(err)) end -- 资源清理代码在这里执行 print("Resource cleaned up") end lanes.gen("any", safe_task)():join()

4.4 线程安全与Lua状态

问题：在多个线程中共享同一个Lua状态。

解决方案：

每个线程使用独立的Lua状态。
避免在Lua状态间直接传递复杂对象。

4.4.1 独立状态示例

-- 正确做法：每个线程独立状态 local lanes = require("lanes").configure() local function worker() local L = luaL_newstate() luaL_openlibs(L) -- 在独立状态中执行代码 luaL_dostring(L, "print('Hello from independent state')") lua_close(L) end lanes.gen("any", worker)():join()

4.5 性能瓶颈

问题：线程间通信开销过大。

解决方案：

批量处理任务。
减少锁的持有时间。

4.5.1 批量处理示例

local lanes = require("lanes").configure() local channel = lanes.channel("batch") local producer = lanes.gen("any", function() local batch = {} for i = 1, 100 do table.insert(batch, "Data " .. i) if #batch >= 10 then channel:send(batch) batch = {} end end if #batch > 0 then channel:send(batch) end channel:send(nil) end) local consumer = lanes.gen("any", function() while true do local batch = channel:receive() if batch == nil then break end for _, data in ipairs(batch) do print("Processing: " .. data) end end end) producer() consumer()

五、实际应用案例

5.1 高并发网络服务器

在游戏服务器或Web服务器中，使用Lua多线程处理并发连接。

5.1.1 简化模型

local lanes = require("lanes").configure() local function handle_connection(conn) -- 处理连接 print("Handling connection from " .. conn.peer) conn:send("Hello from Lua threadn") conn:close() end local server = lanes.gen("any", function() -- 模拟监听 for i = 1, 10 do local conn = { peer = "client_" .. i } lanes.gen("any", handle_connection)(conn) end end) server():join()

5.2 数据并行处理

在科学计算或数据处理中，使用多线程并行处理数据块。

5.2.1 数据分块处理

local lanes = require("lanes").configure() local function process_chunk(chunk) local result = {} for _, value in ipairs(chunk) do table.insert(result, value * 2) -- 示例处理 end return result end local data = {1,2,3,4,5,6,7,8,9,10} local chunk_size = 2 local chunks = {} for i = 1, #data, chunk_size do local chunk = {} for j = i, math.min(i+chunk_size-1, #data) do table.insert(chunk, data[j]) end table.insert(chunks, chunk) end local results = {} for i, chunk in ipairs(chunks) do local h = lanes.gen("table", process_chunk)(chunk) table.insert(results, h) end for i, h in ipairs(results) do local result = h[1] print("Chunk " .. i .. " result: " .. table.concat(result, ", ")) end