《Lua游戏开发实战》2.2 协程（Coroutines）

January 22, 2025

2.2 协程（Coroutines）

协程（Coroutines）是 Lua 中用于实现协作式多任务处理的机制。与操作系统线程不同，协程是由用户控制的轻量级线程，可以在执行过程中暂停和恢复。协程非常适合用于实现异步任务、状态机和迭代器等场景。本节将详细介绍协程的概念、用法及其在实际开发中的应用。

1. 协程的基本概念

1.1 什么是协程

协程是一种用户态的轻量级线程，可以在执行过程中暂停和恢复。与操作系统线程不同，协程的切换由用户控制，不需要操作系统的介入。

特点：
- 轻量级：协程的创建和切换开销远小于操作系统线程。
- 协作式：协程的切换由用户控制，而不是由操作系统调度。
- 单线程：协程在单线程中运行，避免了多线程编程中的同步问题。

1.2 协程的状态

协程有三种状态：

挂起（suspended）：协程被创建后处于挂起状态，等待被启动。
运行（running）：协程正在执行。
死亡（dead）：协程执行完毕或发生错误。

2. 协程的创建与操作

2.1 创建协程

使用 coroutine.create 函数创建协程，参数是一个函数。

语法：

1

local co = coroutine.create(function)

示例：

1
2
3


local co = coroutine.create(function()  
    print("协程开始执行")  
end)  

2.2 启动协程

使用 coroutine.resume 函数启动协程，使其从挂起状态变为运行状态。

语法：
1

coroutine.resume(co, ...)

示例：

1
2
3
4


local co = coroutine.create(function()  
    print("协程开始执行")  
end)  
coroutine.resume(co)  -- 输出 "协程开始执行"  

2.3 挂起协程

使用 coroutine.yield 函数挂起协程，使其从运行状态变为挂起状态。

语法：
1

coroutine.yield(...)

示例：

1
2
3
4
5
6
7


local co = coroutine.create(function()  
    print("协程开始执行")  
    coroutine.yield()  
    print("协程恢复执行")  
end)  
coroutine.resume(co)  -- 输出 "协程开始执行"  
coroutine.resume(co)  -- 输出 "协程恢复执行"  

2.4 获取协程状态

使用 coroutine.status 函数获取协程的当前状态。

语法：

1

local status = coroutine.status(co)

示例：

1
2
3
4
5


local co = coroutine.create(function()  
    coroutine.yield()  
end)  
coroutine.resume(co)  
print(coroutine.status(co))  -- 输出 "suspended"  

2.5 检查协程是否可恢复

使用 coroutine.isyieldable 函数检查当前协程是否可以被挂起。

语法：

1

local isYieldable = coroutine.isyieldable()

示例：

1
2
3
4


local co = coroutine.create(function()  
    print(coroutine.isyieldable())  -- 输出 true  
end)  
coroutine.resume(co)  

3. 协程的应用场景

3.1 异步任务处理

协程非常适合用于处理异步任务，例如网络请求和文件读写。通过协程，可以将异步任务转换为同步代码，提高代码的可读性。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


local function asyncTask()  
    coroutine.yield("任务进行中")  
    return "任务完成"  
end  

local co = coroutine.create(asyncTask)  
local status, result = coroutine.resume(co)  
print(result)  -- 输出 "任务进行中"  
status, result = coroutine.resume(co)  
print(result)  -- 输出 "任务完成"  

3.2 状态机

协程可以用于实现状态机，通过 yield 和 resume 控制状态的切换。

示例：

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


local function stateMachine()  
    while true do  
        print("状态1")  
        coroutine.yield()  
        print("状态2")  
        coroutine.yield()  
    end  
end  

local co = coroutine.create(stateMachine)  
coroutine.resume(co)  -- 输出 "状态1"  
coroutine.resume(co)  -- 输出 "状态2"  
coroutine.resume(co)  -- 输出 "状态1"  

3.3 迭代器

协程可以用于实现迭代器，通过 yield 返回迭代器的每个元素。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


local function iterator(t)  
    for i, v in ipairs(t) do  
        coroutine.yield(v)  
    end  
end  

local co = coroutine.create(iterator)  
local t = {1, 2, 3}  
coroutine.resume(co, t)  -- 输出 1  
coroutine.resume(co, t)  -- 输出 2  
coroutine.resume(co, t)  -- 输出 3  

4. 协程的高级特性

4.1 协程的参数传递

协程可以通过 resume 和 yield 传递参数。

示例：

1
2
3
4
5
6
7
8


local co = coroutine.create(function(a, b)  
    local c = coroutine.yield(a + b)  
    return c  
end)  
local status, result = coroutine.resume(co, 10, 20)  
print(result)  -- 输出 30  
status, result = coroutine.resume(co, 40)  
print(result)  -- 输出 40  

4.2 协程的错误处理

协程可以通过 resume 返回错误信息。

示例：

1
2
3
4
5
6
7


local co = coroutine.create(function()  
    error("协程发生错误")  
end)  
local status, err = coroutine.resume(co)  
if not status then  
    print(err)  -- 输出 "协程发生错误"  
end  

4.3 协程的嵌套

协程可以嵌套使用，即在一个协程中启动另一个协程。

示例：

1
2
3
4
5
6
7
8
9


local co1 = coroutine.create(function()  
    print("协程1开始执行")  
    local co2 = coroutine.create(function()  
        print("协程2开始执行")  
    end)  
    coroutine.resume(co2)  
    print("协程1恢复执行")  
end)  
coroutine.resume(co1)  

5. 协程的最佳实践

5.1 避免阻塞操作

协程是单线程的，阻塞操作会导致整个程序挂起。建议将阻塞操作放在单独的线程中执行。

5.2 合理使用 `yield`

yield 是协程的核心操作，但过度使用会导致代码难以理解和维护。建议仅在必要时使用 yield。

5.3 为协程编写文档

为协程编写文档，说明协程的功能和使用方法，可以提高代码的可读性和可维护性。

示例：

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


--[[  
协程: myCoroutine  
功能: 实现一个简单的状态机  
状态:  
  - 状态1: 打印 "状态1"  
  - 状态2: 打印 "状态2"  
]]  
local function myCoroutine()  
    while true do  
        print("状态1")  
        coroutine.yield()  
        print("状态2")  
        coroutine.yield()  
    end  
end  

6. 总结

协程是 Lua 中用于实现协作式多任务处理的强大机制。通过协程，开发者可以轻松实现异步任务、状态机和迭代器等场景。掌握协程的用法是编写高效、灵活代码的关键。通过本节的学习，读者应能够熟练创建和操作协程，并在实际开发中应用这些技术。