11.1 协同程序的概念

11.1 协同程序的概念

Lua 协同程序 (Coroutines) 详解：概念、实践与代码示例

导言

在并发编程的世界中，我们常常需要处理多个任务看似同时执行的需求。Lua 语言提供了一种轻量级的并发机制——协同程序 (Coroutines)，它允许你在单个线程内实现类似多线程的效果，但其本质是协作式的而非抢占式的。理解协同程序的概念、原理和使用方法，对于编写高效、清晰的 Lua 代码至关重要，尤其是在游戏开发、事件驱动编程和状态机实现等领域。

1. 协同程序 (Coroutines) 的概念

1.1 什么是协同程序？

协同程序，又称协程、协作式例程，是一种用户态的轻量级线程。与操作系统内核管理的线程不同，协同程序完全由程序员在应用程序层面控制其执行和切换。你可以将其视为“轻量级线程”，但更准确的描述是“协作式多任务”的实现方式。

核心特点：

• 协作式 (Cooperative): 协同程序的切换完全由程序自身控制。一个协同程序主动让出 (yield) 执行权后，另一个协同程序才能继续执行。没有操作系统层面的抢占式调度。

• 单线程上下文: 所有的协同程序都运行在同一个线程中。这意味着它们共享相同的全局环境和资源，避免了多线程编程中常见的锁竞争和上下文切换开销。

• 非抢占式 (Non-preemptive): 一个正在运行的协同程序会一直执行，直到它显式地暂停 (yield) 或结束。不会被外部因素（如时间片耗尽）打断。

• 轻量级: 创建和切换协同程序的开销远小于线程，因为它避免了操作系统内核的介入。

1.2 协同程序与线程的区别

理解协同程序和线程的区别至关重要，它们虽然都服务于并发编程，但在实现机制和适用场景上有着显著的不同。

总结：

• 线程： 更强大，可以实现真正的并行，但开销大，编程复杂。适用于需要充分利用多核 CPU 性能的场景。

• 协同程序： 更轻量级，开销小，编程相对简单，适用于 IO 密集型、事件驱动、需要模拟并发但不需要真正并行的场景。

1.3 Lua 中的协同程序

Lua 语言内置了对协同程序的强大支持。Lua 的协同程序库提供了一组函数，用于创建、启动、暂停、恢复和查询协同程序的状态。

核心 API：

• coroutine.create (f): 创建一个新的协同程序，参数 f 是一个函数，表示协同程序的入口点。coroutine.create 仅创建协同程序，并不会立即执行它。

• coroutine.resume (co, ...): 启动或恢复一个已暂停的协同程序 co。可以传递参数给协同程序，参数会作为 coroutine.yield 的返回值返回给暂停的协同程序。

• coroutine.yield (...): 暂停当前协同程序的执行，并将执行权交还给调用 coroutine.resume 的地方。可以传递参数给 coroutine.yield，这些参数会作为 coroutine.resume 的返回值返回给恢复协同程序的地方。

• coroutine.status (co): 返回协同程序 co 的状态，可能的状态值包括："running" (正在运行), "suspended" (已暂停), "normal" (已挂起，但未开始运行或已完成), "dead" (已结束)。

• coroutine.running (): 返回当前正在运行的协同程序，如果没有协同程序正在运行，则返回 nil。

• coroutine.wrap (f): 创建一个包装函数，每次调用该函数都会恢复对应的协同程序。与 coroutine.create 类似，参数 f 是协同程序的入口函数。coroutine.wrap 返回一个函数，而不是协同程序对象本身。

2. 协同程序的代码实践与详解

接下来，我们将通过一系列代码示例，深入理解 Lua 协同程序的各个方面。

2.1 创建和启动协同程序： coroutine.create 和 coroutine.resume

-- 定义一个协同程序函数
local function myCoroutineFunction ()
  print("Coroutine started")
  coroutine.yield() -- 暂停协同程序
  print("Coroutine resumed")
  return "Coroutine finished"
end
-- 创建协同程序
local co = coroutine.create(myCoroutineFunction)
print("Coroutine created, status:", coroutine.status(co)) -- 输出: Coroutine created, status: suspended
-- 启动协同程序
print("Resuming coroutine...")
local status, result = coroutine.resume(co)
print("Coroutine status after resume:", status, coroutine.status(co)) -- 输出: Coroutine status after resume: true	suspended
print("Coroutine output:", result) -- 输出: Coroutine output: nil (因为第一次 yield 没有返回值)
-- 再次恢复协同程序
print("Resuming coroutine again...")
status, result = coroutine.resume(co)
print("Coroutine status after second resume:", status, coroutine.status(co)) -- 输出: Coroutine status after second resume: true	dead
print("Coroutine output:", result) -- 输出: Coroutine output: Coroutine finished
​

代码详解：

1. local function myCoroutineFunction () ... end: 定义了一个函数 myCoroutineFunction，这个函数将作为我们协同程序的入口点。

2. local co = coroutine.create(myCoroutineFunction): 使用 coroutine.create 创建了一个新的协同程序。co 变量现在引用了这个新创建的协同程序对象。此时，协同程序的状态是 "suspended" (已挂起)，意味着它已经创建但尚未开始执行。

3. coroutine.status(co): 使用 coroutine.status 函数查询协同程序 co 的状态。

4. coroutine.resume(co): 使用 coroutine.resume 函数启动协同程序 co。

   • coroutine.resume 的第一个返回值 status 是一个布尔值，表示恢复操作是否成功。通常为 true，除非遇到错误。

   • 后续的返回值是协同程序 coroutine.yield 返回的值，或者协同程序函数本身的返回值（当协同程序正常结束时）。

5. coroutine.yield(): 在 myCoroutineFunction 中，coroutine.yield() 语句暂停了协同程序的执行，并将执行权交还给了调用 coroutine.resume 的地方。此时，协同程序的状态变为 "suspended"。

6. 第二次 coroutine.resume(co): 再次调用 coroutine.resume(co) 会从上次 coroutine.yield() 暂停的地方继续执行协同程序。当 myCoroutineFunction 函数执行完毕，协同程序结束，状态变为 "dead"。

总结：

• coroutine.create 负责创建协同程序对象。

• coroutine.resume 负责启动或恢复协同程序的执行。

• coroutine.yield 负责暂停协同程序的执行，并将执行权交还给恢复它的地方。

• 协同程序的状态可以通过 coroutine.status 查询。

2.2 协同程序之间的参数传递

协同程序之间可以通过 coroutine.resume 和 coroutine.yield 互相传递数据。

2.2.1 coroutine.resume 传递参数给协同程序

local function coroutineFunctionWithParams (param1, param2)
  print("Coroutine received parameters:", param1, param2)
  coroutine.yield(param1 + param2) -- yield 并返回计算结果
  print("Coroutine resumed again")
  return "Coroutine finished"
end
local co = coroutine.create(coroutineFunctionWithParams)
print("Resuming coroutine with parameters...")
local status, yieldValue = coroutine.resume(co, 10, 20) -- 传递参数 10 和 20
print("Coroutine status:", status, coroutine.status(co)) -- 输出: Coroutine status: true	suspended
print("Yielded value:", yieldValue) -- 输出: Yielded value: 30 (10 + 20)
print("Resuming coroutine again...")
status, finalResult = coroutine.resume(co)
print("Coroutine status:", status, coroutine.status(co)) -- 输出: Coroutine status: true	dead
print("Final result:", finalResult) -- 输出: Final result: Coroutine finished
​

代码详解：

1. coroutineFunctionWithParams (param1, param2): 协同程序函数接收两个参数 param1 和 param2。

2. coroutine.yield(param1 + param2): coroutine.yield 不仅暂停协同程序，还返回了 param1 + param2 的计算结果 30。

3. coroutine.resume(co, 10, 20): 在调用 coroutine.resume 时，我们传递了额外的参数 10 和 20。这些参数会被传递给 coroutineFunctionWithParams 函数，作为它的 param1 和 param2 的值。

4. yieldValue = coroutine.resume(...): coroutine.resume 的第二个返回值 yieldValue 就是 coroutine.yield 返回的值 30。

2.2.2 coroutine.yield 传递参数给 coroutine.resume

local function producerCoroutine ()
  for i = 1, 5 do
    print("Producer yielding value:", i)
    coroutine.yield(i) -- 每次 yield 返回一个值
  end
  return "Producer finished"
end
local coProducer = coroutine.create(producerCoroutine)
local function consumerFunction ()
  while true do
    local status, value = coroutine.resume(coProducer) -- 恢复 producer
    if not status then -- producer 结束
      print("Producer finished:", value) -- value 是 producerCoroutine 的返回值
      break
    end
    print("Consumer received value:", value)
    -- 处理接收到的值 (value)
  end
end
consumerFunction()
​

代码详解：

1. producerCoroutine: 这个协同程序模拟一个生产者，循环生成 1 到 5 的数字，并每次使用 coroutine.yield(i) 返回一个数字。

2. consumerFunction: 这个函数模拟一个消费者，在一个循环中不断地恢复 producerCoroutine。

3. local status, value = coroutine.resume(coProducer): 每次 coroutine.resume 调用都会恢复 producerCoroutine，并接收 coroutine.yield 返回的值 value。

4. if not status then ... break end: 当 producerCoroutine 执行完毕并返回 "Producer finished" 时，后续的 coroutine.resume 调用会返回 false 作为状态，以及生产者函数的返回值作为第二个返回值。消费者函数通过检查 status 来判断生产者是否结束。

总结：

• coroutine.resume 可以向协同程序传递参数，这些参数会成为协同程序入口函数的参数。

• coroutine.yield 可以向恢复它的 coroutine.resume 返回值，实现双向的数据传递。

2.3 coroutine.wrap 的使用

coroutine.wrap(f) 提供了一种更简洁的方式来使用协同程序。它返回一个函数，每次调用这个函数都会恢复对应的协同程序，并执行到下一个 coroutine.yield 或协同程序结束。

local function wrappedCoroutineFunction ()
  print("Wrapped coroutine started")
  coroutine.yield(1)
  print("Wrapped coroutine resumed")
  coroutine.yield(2)
  print("Wrapped coroutine finished")
  return 3
end
local wrappedCoroutine = coroutine.wrap(wrappedCoroutineFunction)
print("Calling wrapped coroutine first time...")
local value1 = wrappedCoroutine() -- 第一次调用，恢复协同程序到第一个 yield
print("Wrapped coroutine yielded:", value1) -- 输出: Wrapped coroutine yielded: 1
print("Calling wrapped coroutine second time...")
local value2 = wrappedCoroutine() -- 第二次调用，恢复协同程序到第二个 yield
print("Wrapped coroutine yielded:", value2) -- 输出: Wrapped coroutine yielded: 2
print("Calling wrapped coroutine third time...")
local value3 = wrappedCoroutine() -- 第三次调用，协同程序结束
print("Wrapped coroutine returned:", value3) -- 输出: Wrapped coroutine returned: 3
print("Calling wrapped coroutine fourth time...")
local value4 = wrappedCoroutine() -- 第四次调用，协同程序已结束，返回 nil
print("Wrapped coroutine return value (after finished):", value4) -- 输出: Wrapped coroutine return value (after finished): nil
​

代码详解：

1. local wrappedCoroutine = coroutine.wrap(wrappedCoroutineFunction): 使用 coroutine.wrap 创建了一个包装函数 wrappedCoroutine。

2. wrappedCoroutine(): 每次调用 wrappedCoroutine() 都会恢复底层的协同程序，并执行到下一个 coroutine.yield 或协同程序结束。

3. 返回值: wrappedCoroutine() 的返回值是 coroutine.yield 返回的值，或者协同程序函数的返回值（当协同程序结束时）。如果协同程序已经结束，再次调用 wrappedCoroutine() 将返回 nil。

总结：

• coroutine.wrap 返回一个函数，简化了协同程序的启动和恢复过程。

• 每次调用包装函数都会恢复协同程序，并执行到下一个 coroutine.yield 或结束。

• 包装函数的返回值是 coroutine.yield 或协同程序函数的返回值。

2.4 协同程序的状态： coroutine.status 和 coroutine.running

• coroutine.status(co): 我们已经多次使用 coroutine.status 来查询协同程序的状态。它返回以下字符串之一：

  • "running": 协同程序正在运行 (只有在协同程序内部调用 coroutine.status(coroutine.running()) 时才会出现)。

  • "suspended": 协同程序已暂停 (通过 coroutine.yield)。

  • "normal": 协同程序已挂起，但尚未开始运行，或者已经执行完毕但尚未被垃圾回收。

  • "dead": 协同程序已结束执行，无法再次恢复。

• coroutine.running(): 返回当前正在运行的协同程序。如果在主线程中调用，且没有协同程序正在运行，则返回 nil。

local function statusCoroutine ()
  print("Coroutine status at start:", coroutine.status(coroutine.running())) -- 输出: running
  coroutine.yield()
  print("Coroutine status after yield:", coroutine.status(coroutine.running())) -- 输出: running (因为 coroutine.running() 始终返回当前协程)
  return "Status coroutine finished"
end
local coStatus = coroutine.create(statusCoroutine)
print("Coroutine status before resume:", coroutine.status(coStatus)) -- 输出: suspended
coroutine.resume(coStatus)
print("Coroutine status after first resume and yield:", coroutine.status(coStatus)) -- 输出: suspended
coroutine.resume(coStatus)
print("Coroutine status after second resume and finish:", coroutine.status(coStatus)) -- 输出: dead
​

代码详解：

• 在协同程序内部，coroutine.running() 始终返回当前协同程序对象本身。

• 在协同程序外部，coroutine.status(co) 可以准确反映协同程序的状态变化。

3. 协同程序的应用场景

协同程序在很多场景下都非常有用，尤其是在需要处理异步操作、事件驱动、状态管理等问题时。

3.1 生成器 (Generators) 和迭代器 (Iterators)

协同程序非常适合实现生成器和迭代器，可以按需生成序列中的元素，而不是一次性生成所有元素，节省内存并提高效率。

-- 生成斐波那契数列的生成器
local function fibonacciGenerator ()
  local a, b = 0, 1
  while true do
    coroutine.yield(a) -- yield 当前值
    a, b = b, a + b
  end
end
local fibGen = coroutine.wrap(fibonacciGenerator)
for i = 1, 10 do
  print("Fibonacci number", i, ":", fibGen()) -- 每次调用 fibGen() 获取下一个斐波那契数
end
​

代码详解：

• fibonacciGenerator 函数使用 while true 循环无限生成斐波那契数列。

• coroutine.yield(a) 每次暂停并返回当前的斐波那契数 a。

• coroutine.wrap(fibonacciGenerator) 创建了一个包装函数 fibGen，每次调用 fibGen() 都会恢复生成器协同程序，并获取下一个斐波那契数。

• for i = 1, 10 do ... end 循环调用 fibGen() 获取前 10 个斐波那契数。

3.2 状态机 (State Machines)

协同程序可以优雅地实现状态机，每个状态可以对应一个协同程序，状态切换可以通过 coroutine.yield 和 coroutine.resume 来实现。

local function stateMachine ()
  local state = "STATE_A"
  while true do
    if state == "STATE_A" then
      print("Entering STATE_A")
      -- 执行 STATE_A 的逻辑
      state = "STATE_B" -- 状态切换
      coroutine.yield() -- 暂停，等待下次状态切换
    elseif state == "STATE_B" then
      print("Entering STATE_B")
      -- 执行 STATE_B 的逻辑
      state = "STATE_C" -- 状态切换
      coroutine.yield()
    elseif state == "STATE_C" then
      print("Entering STATE_C")
      -- 执行 STATE_C 的逻辑
      state = "STATE_A" -- 状态切换，循环回 STATE_A
      coroutine.yield()
    end
  end
end
local sm = coroutine.create(stateMachine)
for i = 1, 5 do
  coroutine.resume(sm) -- 每次 resume 切换到下一个状态
end
​

代码详解：

• stateMachine 函数模拟一个简单的状态机，包含 STATE_A, STATE_B, STATE_C 三个状态。

• state 变量记录当前状态。

• while true 循环驱动状态机不断运行。

• if state == ... then ... end 结构根据当前状态执行相应的逻辑，并切换到下一个状态。

• coroutine.yield() 在每个状态执行完毕后暂停协同程序，等待下次 coroutine.resume 触发状态切换。

• for i = 1, 5 do ... end 循环模拟状态机的运行过程，每次 coroutine.resume(sm) 触发状态切换。

3.3 事件处理和异步操作

协同程序可以用来处理异步事件和模拟异步操作，例如网络请求、文件 IO 等。虽然 Lua 本身是同步的，但通过协同程序，我们可以实现类似异步编程的效果，避免阻塞主线程。

示例 (伪代码，需要结合实际的异步 IO 库):

-- 模拟异步网络请求
local function asyncRequestCoroutine (url)
  print("Starting request to", url)
  -- 假设有一个异步 IO 函数 async_http_get(url, callback)
  -- callback 会在请求完成后被调用，并将结果传递给 callback
  async_http_get(url, function(result)
    coroutine.resume(asyncRequestCoroutine, result) -- 请求完成后恢复协同程序，并传递结果
  end)
  return coroutine.yield() -- 暂停协同程序，等待异步请求完成
end
local coRequest = coroutine.create(asyncRequestCoroutine)
coroutine.resume(coRequest, "http://example.com") -- 启动请求
-- 主线程继续执行其他任务，不会被网络请求阻塞
print("Main thread continues to work...")
-- 当网络请求完成时，callback 会被调用，并恢复 asyncRequestCoroutine 协同程序
-- coroutine.resume(asyncRequestCoroutine, result) 会将 result 作为 coroutine.yield() 的返回值返回
-- 协同程序继续执行，处理请求结果
​

代码详解 (伪代码)：

• asyncRequestCoroutine 模拟一个异步网络请求。

• async_http_get 是一个假设的异步 IO 函数，它接受 URL 和回调函数作为参数。

• async_http_get 在后台发起网络请求，并立即返回，不会阻塞主线程。

• 回调函数 function(result) ... end 在网络请求完成后被调用。

• coroutine.resume(asyncRequestCoroutine, result) 在回调函数中恢复 asyncRequestCoroutine 协同程序，并将请求结果 result 传递给它。

• coroutine.yield() 在协同程序中暂停执行，等待异步请求完成。当请求完成并通过 coroutine.resume 恢复后，coroutine.yield() 会返回 result，协同程序可以继续处理请求结果。

注意： Lua 标准库本身不提供原生的异步 IO 功能。要实现真正的异步 IO，通常需要使用扩展库 (例如 lua-nginx-module in OpenResty, luasocket, libuv 等)。上面的代码只是一个概念示例，用于说明如何使用协同程序来模拟异步操作。

4. 总结与最佳实践

协同程序是 Lua 语言中一种强大而灵活的并发编程工具。它以协作式的方式实现轻量级多任务，在单线程环境下提供了类似并发的效果，并且开销小，易于理解和使用。

核心优势：

• 轻量级并发: 在单线程内实现并发，避免了多线程的复杂性和开销。

• 协作式调度: 程序自身控制切换，逻辑清晰，易于调试。

• 适用于 IO 密集型和事件驱动场景: 可以有效地处理异步操作，提高程序响应性和效率。

最佳实践：

• 合理使用 coroutine.yield: 在适当的地方使用 coroutine.yield 暂停协同程序，让出执行权，避免长时间占用 CPU。

• 避免过度使用协同程序: 虽然协同程序轻量级，但过多的协同程序也会增加管理开销。根据实际需求选择合适的并发模型。

• 注意共享资源访问: 虽然协同程序在单线程内，但仍然需要注意共享资源的访问，避免数据竞争 (虽然概率较低，但仍需谨慎)。

• 结合异步 IO 库使用: 如果需要处理真正的异步 IO 操作，需要结合 Lua 的异步 IO 扩展库 (例如 luasocket, libuv 等) 来发挥协同程序的最大威力。

总结:

理解和掌握 Lua 协同程序的概念和使用方法，能够让你编写出更高效、更清晰、更易于维护的 Lua 代码。在游戏开发、服务器编程、脚本自动化等领域，协同程序都扮演着重要的角色。希望本文的详细解释和代码示例能够帮助你深入理解 Lua 协同程序，并在实际项目中灵活运用。