Lua新线程创建与内存释放机制详解如何正确管理避免内存泄漏

威震华夏关云长

1. Lua线程（协程）基本概念

Lua中的线程实际上是一种协程（coroutine），与我们通常所说的操作系统级线程有本质区别。Lua协程是协作式的多任务处理机制，它们允许在单个线程内实现多个执行流程的切换，但这些流程不是并行执行的，而是在显式地让出控制权时进行切换。

Lua协程具有以下特点：

• 轻量级：创建和切换成本低
• 协作式：必须显式让出控制权
• 共享地址空间：所有协程共享相同的全局变量和环境
• 拥有独立的栈：每个协程有自己的调用栈

在Lua中，协程主要用于实现协作式多任务、迭代器、状态机等功能，是实现复杂控制流的重要工具。

2. Lua线程的创建方法

在Lua中，创建新线程（协程）主要通过以下几种方式：

2.1 使用coroutine.create()

coroutine.create()是最基本的协程创建方法，它接受一个函数作为参数，并返回一个新创建的协程对象。

2. -- 创建一个简单的协程
3. co = coroutine.create(function ()
4.     for i = 1, 5 do
5.         print("协程输出: " .. i)
6.         coroutine.yield()  -- 让出控制权
7.     end
8. end)
10. -- 启动并运行协程
11. coroutine.resume(co)
12. coroutine.resume(co)
13. coroutine.resume(co)
14. coroutine.resume(co)
15. coroutine.resume(co)

复制代码

2.2 使用coroutine.wrap()

coroutine.wrap()也创建一个协程，但它返回一个函数而不是协程对象。每次调用这个函数都会恢复协程的执行。

2. -- 使用wrap创建协程
3. co_func = coroutine.wrap(function ()
4.     for i = 1, 3 do
5.         print("wrap协程输出: " .. i)
6.         coroutine.yield()
7.     end
8. end)
10. -- 调用返回的函数来恢复协程
11. co_func()
12. co_func()
13. co_func()

复制代码

2.3 带参数的协程创建

协程函数可以接受参数，这些参数在首次调用coroutine.resume()时传入：

2. -- 创建带参数的协程
3. co = coroutine.create(function (a, b)
4.     print("协程接收到参数:", a, b)
5.     local sum = a + b
6.     coroutine.yield(sum)  -- 返回计算结果
7.    
8.     local product = a * b
9.     return product  -- 最终返回值
10. end)
12. -- 首次恢复协程并传入参数
13. local success, sum = coroutine.resume(co, 10, 20)
14. print("协程第一次返回:", success, sum)
16. -- 再次恢复协程
17. local success, product = coroutine.resume(co)
18. print("协程最终返回:", success, product)

复制代码

3. Lua线程的内存管理机制

Lua使用自动内存管理，主要通过垃圾收集器（GC）来管理内存。理解Lua的内存管理机制对于避免内存泄漏至关重要。

3.1 Lua垃圾收集器概述

Lua的垃圾收集器使用了一种增量式标记-清除（Mark-and-Sweep）算法，具有以下特点：

• 自动回收不再使用的内存
• 增量式执行，避免长时间暂停
• 可配置的GC参数（步长、步进倍率等）

3.2 Lua对象的生命周期

在Lua中，所有对象（包括协程）都是自动管理的。对象的生命周期通常如下：

1. 创建：当对象被创建时，内存被分配
2. 使用：对象被引用和使用
3. 不可达：当对象不再被任何变量引用时，成为”垃圾”
4. 回收：GC在适当的时候回收这些垃圾对象的内存

3.3 协程对象的内存结构

每个Lua协程对象包含以下内存结构：

• 独立的栈空间：存储协程的调用栈、局部变量等
• 状态信息：记录协程的当前状态（挂起、运行、死亡等）
• 引用环境：指向全局环境的引用

2. -- 示例：查看协程的内存占用
3. local function measure_memory()
4.     collectgarbage("collect")  -- 先执行一次完整GC
5.     local before = collectgarbage("count")  -- 获取当前内存使用量(KB)
6.    
7.     -- 创建多个协程
8.     local coroutines = {}
9.     for i = 1, 1000 do
10.         coroutines[i] = coroutine.create(function()
11.             local data = string.rep("x", 1000)  -- 每个协程分配一些数据
12.         end)
13.         coroutine.resume(coroutines[i])
14.     end
15.    
16.     local after = collectgarbage("count")
17.     print("创建1000个协程前后内存使用:", before, "KB ->", after, "KB")
18.     print("内存差:", after - before, "KB")
19.    
20.     -- 清除引用
21.     coroutines = nil
22.     collectgarbage("collect")
23.     local final = collectgarbage("count")
24.     print("清理后内存使用:", final, "KB")
25. end
27. measure_memory()

复制代码

4. Lua线程的内存释放机制

Lua线程的内存释放主要依赖于垃圾收集器，但也有一些特殊情况需要注意。

4.1 正常情况下的内存释放

当一个协程对象不再被任何变量引用时，它将成为GC的回收目标：

2. -- 示例：协程的正常内存释放
3. local function create_and_release_coroutine()
4.     -- 创建协程
5.     local co = coroutine.create(function()
6.         local large_data = string.rep("x", 100000)  -- 分配较大内存
7.         print("协程中的数据大小:", #large_data)
8.         coroutine.yield()
9.     end)
10.    
11.     -- 运行协程
12.     coroutine.resume(co)
13.    
14.     -- 协程运行后，large_data变量仍然在协程栈中
15.     -- 此时协程对象co仍然被引用，内存不会被释放
16.    
17.     -- 将co设为nil，移除引用
18.     co = nil
19.    
20.     -- 强制执行GC（仅用于演示，实际代码中通常不需要）
21.     collectgarbage("collect")
22.     print("协程对象已释放")
23. end
25. create_and_release_coroutine()

复制代码

4.2 协程状态与内存释放

协程的状态会影响其内存释放时机：

2. -- 示例：不同状态协程的内存释放
3. local function test_coroutine_states()
4.     -- 创建一个运行中的协程
5.     local running_co = coroutine.create(function()
6.         while true do
7.             coroutine.yield()
8.         end
9.     end)
10.     coroutine.resume(running_co)
11.    
12.     -- 创建一个已完成的协程
13.     local finished_co = coroutine.create(function()
14.         print("这个协程即将完成")
15.     end)
16.     coroutine.resume(finished_co)
17.    
18.     -- 创建一个挂起的协程
19.     local suspended_co = coroutine.create(function()
20.         coroutine.yield("挂起中")
21.     end)
22.     coroutine.resume(suspended_co)
23.    
24.     -- 检查协程状态
25.     print("running_co状态:", coroutine.status(running_co))
26.     print("finished_co状态:", coroutine.status(finished_co))
27.     print("suspended_co状态:", coroutine.status(suspended_co))
28.    
29.     -- 移除所有引用
30.     running_co = nil
31.     finished_co = nil
32.     suspended_co = nil
33.    
34.     -- 强制GC
35.     collectgarbage("collect")
36.     print("所有协程引用已移除")
37. end
39. test_coroutine_states()

复制代码

4.3 协程中的闭包与内存释放

协程中使用的闭包可能会影响内存释放：

2. -- 示例：协程中的闭包与内存
3. local function coroutine_with_closures()
4.     local large_data = string.rep("x", 100000)  -- 大数据
5.    
6.     -- 创建一个闭包函数
7.     local closure = function()
8.         print("闭包访问大数据:", #large_data)
9.     end
10.    
11.     -- 创建协程并使用闭包
12.     local co = coroutine.create(function()
13.         closure()  -- 使用闭包
14.         coroutine.yield()
15.     end)
16.    
17.     coroutine.resume(co)
18.    
19.     -- 即使协程完成，large_data仍然被闭包引用
20.     -- 需要确保闭包也被释放
21.    
22.     -- 移除引用
23.     co = nil
24.     closure = nil
25.     large_data = nil
26.    
27.     collectgarbage("collect")
28.     print("闭包和协程已释放")
29. end
31. coroutine_with_closures()

复制代码

5. 常见的内存泄漏问题和原因

在Lua中使用协程时，可能会遇到一些常见的内存泄漏问题。

5.1 循环引用导致的内存泄漏

当协程之间或协程与其他对象之间存在循环引用时，可能导致内存泄漏：

2. -- 示例：协程间的循环引用
3. local function circular_reference_leak()
4.     local co1, co2
5.    
6.     -- 创建第一个协程
7.     co1 = coroutine.create(function()
8.         -- 在协程1中引用协程2
9.         local ref_to_co2 = co2
10.         print("协程1引用协程2")
11.         coroutine.yield()
12.     end)
13.    
14.     -- 创建第二个协程
15.     co2 = coroutine.create(function()
16.         -- 在协程2中引用协程1
17.         local ref_to_co1 = co1
18.         print("协程2引用协程1")
19.         coroutine.yield()
20.     end)
21.    
22.     -- 运行协程
23.     coroutine.resume(co1)
24.     coroutine.resume(co2)
25.    
26.     -- 即使将co1和co2设为nil，由于协程内部相互引用
27.     -- 它们可能不会被GC回收
28.     co1 = nil
29.     co2 = nil
30.    
31.     -- 强制GC
32.     collectgarbage("collect")
33.     print("注意：循环引用可能导致协程无法被GC回收")
34. end
36. circular_reference_leak()

复制代码

5.2 未完成的协程导致的内存泄漏

如果创建了大量协程但没有让它们正常结束，可能导致内存泄漏：

2. -- 示例：未完成协程导致的内存泄漏
3. local function unfinished_coroutine_leak()
4.     local coroutines = {}
5.    
6.     -- 创建1000个永远不会结束的协程
7.     for i = 1, 1000 do
8.         coroutines[i] = coroutine.create(function()
9.             while true do
10.                 coroutine.yield()
11.             end
12.         end)
13.         coroutine.resume(coroutines[i])
14.     end
15.    
16.     -- 测量内存使用
17.     collectgarbage("collect")
18.     local mem_with_coroutines = collectgarbage("count")
19.     print("1000个未完成协程的内存使用:", mem_with_coroutines, "KB")
20.    
21.     -- 即使将coroutines表设为nil，如果协程仍在运行
22.     -- 它们可能不会被立即回收
23.     coroutines = nil
24.    
25.     -- 强制GC
26.     collectgarbage("collect")
27.     local mem_after_clear = collectgarbage("count")
28.     print("清除引用后的内存使用:", mem_after_clear, "KB")
29.    
30.     -- 注意：未完成的协程可能仍然占用内存
31.     -- 正确做法是确保协程能够正常结束
32. end
34. unfinished_coroutine_leak()

复制代码

5.3 协程栈中保留大数据导致的内存泄漏

如果协程的栈中保留了大量数据，即使协程不再被引用，这些数据也可能不会被及时释放：

2. -- 示例：协程栈中保留大数据
3. local function large_data_in_stack()
4.     local function create_coroutine_with_large_data()
5.         -- 在协程中创建大数据
6.         local large_data = string.rep("x", 1000000)  -- 1MB数据
7.         
8.         -- 执行一些操作
9.         local processed_data = string.upper(large_data)
10.         
11.         -- 让出控制权，但large_data和processed_data仍在栈中
12.         coroutine.yield()
13.         
14.         -- 返回处理结果
15.         return processed_data
16.     end
17.    
18.     -- 创建并运行协程
19.     local co = coroutine.create(create_coroutine_with_large_data)
20.     coroutine.resume(co)
21.    
22.     -- 协程挂起，但栈中的大数据仍然存在
23.     -- 即使协程对象被引用，这些数据也会占用内存
24.    
25.     -- 完成协程
26.     local success, result = coroutine.resume(co)
27.     print("协程完成，结果大小:", #result)
28.    
29.     -- 现在可以安全地释放协程
30.     co = nil
31.     result = nil
32.    
33.     collectgarbage("collect")
34.     print("协程和数据已释放")
35. end
37. large_data_in_stack()

复制代码

6. 如何正确管理Lua线程以避免内存泄漏

为了避免Lua协程相关的内存泄漏，需要采取一些正确的管理策略。

6.1 确保协程正常结束

确保协程能够正常结束是最基本的内存管理策略：

2. -- 示例：确保协程正常结束
3. local function ensure_coroutine_completion()
4.     local coroutines = {}
5.    
6.     -- 创建多个协程，但确保它们能够结束
7.     for i = 1, 10 do
8.         coroutines[i] = coroutine.create(function(count)
9.             for j = 1, count do
10.                 print(string.format("协程%d: 步骤%d", i, j))
11.                 coroutine.yield()
12.             end
13.             print(string.format("协程%d: 完成", i))
14.         end)
15.     end
16.    
17.     -- 运行所有协程直到它们完成
18.     local all_done = false
19.     while not all_done do
20.         all_done = true
21.         for i, co in ipairs(coroutines) do
22.             if coroutine.status(co) ~= "dead" then
23.                 coroutine.resume(co, 5)  -- 每个协程运行5步
24.                 all_done = false
25.             end
26.         end
27.     end
28.    
29.     -- 所有协程已完成，可以安全释放
30.     coroutines = nil
31.     collectgarbage("collect")
32.     print("所有协程已完成并释放")
33. end
35. ensure_coroutine_completion()

复制代码

6.2 使用弱引用表管理协程

弱引用表可以帮助管理协程，避免不必要的引用阻止GC回收：

2. -- 示例：使用弱引用表管理协程
3. local function weak_table_management()
4.     -- 创建一个弱引用表，value为弱引用
5.     local weak_coroutines = setmetatable({}, {__mode = "v"})
6.    
7.     -- 创建并添加协程到弱引用表
8.     for i = 1, 5 do
9.         local co = coroutine.create(function()
10.             print(string.format("协程%d运行中", i))
11.             coroutine.yield()
12.             print(string.format("协程%d完成", i))
13.         end)
14.         
15.         -- 使用协程ID作为key，协程对象作为value
16.         weak_coroutines[i] = co
17.         coroutine.resume(co)
18.     end
19.    
20.     -- 强制GC，观察弱引用表中的协程是否被回收
21.     collectgarbage("collect")
22.     print("GC后弱引用表中的协程数量:", #weak_coroutines)
23.    
24.     -- 手动完成所有协程
25.     for i, co in pairs(weak_coroutines) do
26.         if coroutine.status(co) ~= "dead" then
27.             coroutine.resume(co)
28.         end
29.     end
30.    
31.     -- 再次强制GC
32.     collectgarbage("collect")
33.     print("所有协程完成后，弱引用表中的协程数量:", #weak_coroutines)
34.    
35.     -- 清除弱引用表
36.     weak_coroutines = nil
37.     collectgarbage("collect")
38.     print("弱引用表已清理")
39. end
41. weak_table_management()

复制代码

6.3 避免在协程中创建不必要的闭包

减少协程中不必要的闭包可以降低内存泄漏的风险：

2. -- 示例：避免不必要的闭包
3. local function avoid_unnecessary_closures()
4.     -- 不好的做法：在协程中创建闭包捕获外部变量
5.     local function bad_practice()
6.         local external_data = "外部数据"
7.         
8.         local co = coroutine.create(function()
9.             -- 这个闭包捕获了external_data
10.             local closure = function()
11.                 print("访问外部数据:", external_data)
12.             end
13.             
14.             closure()
15.             coroutine.yield()
16.         end)
17.         
18.         coroutine.resume(co)
19.         -- 即使协程完成，external_data可能不会被释放
20.         -- 因为闭包仍然引用它
21.         
22.         co = nil
23.         collectgarbage("collect")
24.     end
25.    
26.     -- 好的做法：避免不必要的闭包
27.     local function good_practice()
28.         local co = coroutine.create(function()
29.             -- 直接使用局部变量，而不是闭包
30.             local local_data = "局部数据"
31.             print("使用局部数据:", local_data)
32.             coroutine.yield()
33.         end)
34.         
35.         coroutine.resume(co)
36.         -- 没有不必要的闭包，内存更容易释放
37.         
38.         co = nil
39.         collectgarbage("collect")
40.     end
41.    
42.     print("测试不好的做法:")
43.     bad_practice()
44.    
45.     print("\n测试好的做法:")
46.     good_practice()
47. end
49. avoid_unnecessary_closures()

复制代码

6.4 使用协程池管理协程生命周期

协程池是一种有效管理协程生命周期的模式，特别适用于需要频繁创建和销毁协程的场景：

2. -- 示例：协程池实现
3. local CoroutinePool = {
4.     pools = {},
5.     maxPoolSize = 10,  -- 每种类型协程的最大池大小
6. }
8. -- 创建或获取协程池
9. function CoroutinePool.getPool(type)
10.     if not CoroutinePool.pools[type] then
11.         CoroutinePool.pools[type] = {}
12.     end
13.     return CoroutinePool.pools[type]
14. end
16. -- 从池中获取协程
17. function CoroutinePool.acquire(type, func)
18.     local pool = CoroutinePool.getPool(type)
19.    
20.     if #pool > 0 then
21.         -- 从池中取出一个协程
22.         local co = table.remove(pool)
23.         -- 重置协程的函数
24.         -- 注意：Lua 5.1+ 不支持直接重置协程函数，这里只是示例
25.         -- 实际实现可能需要使用其他方法
26.         return co
27.     else
28.         -- 创建新协程
29.         return coroutine.create(func)
30.     end
31. end
33. -- 将协程返回池中
34. function CoroutinePool.release(type, co)
35.     local pool = CoroutinePool.getPool(type)
36.    
37.     -- 检查协程状态和池大小
38.     if coroutine.status(co) == "dead" or #pool >= CoroutinePool.maxPoolSize then
39.         -- 如果协程已结束或池已满，不回收
40.         return
41.     end
42.    
43.     -- 将协程放回池中
44.     table.insert(pool, co)
45. end
47. -- 清理协程池
48. function CoroutinePool.clear()
49.     for type, pool in pairs(CoroutinePool.pools) do
50.         CoroutinePool.pools[type] = {}
51.     end
52.     collectgarbage("collect")
53. end
55. -- 使用协程池的示例
56. local function use_coroutine_pool()
57.     -- 定义协程函数
58.     local task_func = function(id)
59.         print(string.format("任务%d开始", id))
60.         coroutine.yield()
61.         print(string.format("任务%d继续", id))
62.         coroutine.yield()
63.         print(string.format("任务%d完成", id))
64.     end
65.    
66.     -- 获取并使用协程
67.     local co1 = CoroutinePool.acquire("task", task_func)
68.     coroutine.resume(co1, 1)
69.    
70.     local co2 = CoroutinePool.acquire("task", task_func)
71.     coroutine.resume(co2, 2)
72.    
73.     -- 继续执行协程
74.     coroutine.resume(co1)
75.     coroutine.resume(co2)
76.    
77.     -- 完成协程
78.     coroutine.resume(co1)
79.     coroutine.resume(co2)
80.    
81.     -- 释放协程回池中
82.     CoroutinePool.release("task", co1)
83.     CoroutinePool.release("task", co2)
84.    
85.     -- 再次获取协程（应该从池中获取）
86.     local co3 = CoroutinePool.acquire("task", task_func)
87.     coroutine.resume(co3, 3)
88.     coroutine.resume(co3)
89.     coroutine.resume(co3)
90.    
91.     -- 释放协程
92.     CoroutinePool.release("task", co3)
93.    
94.     -- 清理池
95.     CoroutinePool.clear()
96.     print("协程池已清理")
97. end
99. use_coroutine_pool()

复制代码

7. 最佳实践和代码示例

7.1 协程生命周期管理最佳实践

2. -- 示例：协程生命周期管理最佳实践
3. local function coroutine_lifecycle_management()
4.     -- 1. 使用协程管理器来跟踪所有活动协程
5.     local CoroutineManager = {
6.         active_coroutines = {},
7.         next_id = 1
8.     }
9.    
10.     -- 注册新协程
11.     function CoroutineManager.register(func, ...)
12.         local co = coroutine.create(func)
13.         local id = CoroutineManager.next_id
14.         CoroutineManager.next_id = CoroutineManager.next_id + 1
15.         
16.         -- 存储协程及其元数据
17.         CoroutineManager.active_coroutines[id] = {
18.             coroutine = co,
19.             status = "running",
20.             created_at = os.time()
21.         }
22.         
23.         -- 启动协程并传递参数
24.         local success, err = coroutine.resume(co, ...)
25.         if not success then
26.             print("协程启动错误:", err)
27.             CoroutineManager.active_coroutines[id] = nil
28.             return nil
29.         end
30.         
31.         return id
32.     end
33.    
34.     -- 更新所有协程
35.     function CoroutineManager.update()
36.         local dead_coroutines = {}
37.         
38.         for id, co_data in pairs(CoroutineManager.active_coroutines) do
39.             local co = co_data.coroutine
40.             
41.             if coroutine.status(co) ~= "dead" then
42.                 -- 恢复协程
43.                 local success, err = coroutine.resume(co)
44.                 if not success then
45.                     print("协程执行错误:", err)
46.                     table.insert(dead_coroutines, id)
47.                 end
48.             else
49.                 -- 标记死亡的协程
50.                 table.insert(dead_coroutines, id)
51.             end
52.         end
53.         
54.         -- 清理死亡的协程
55.         for _, id in ipairs(dead_coroutines) do
56.             CoroutineManager.active_coroutines[id] = nil
57.         end
58.     end
59.    
60.     -- 获取活动协程数量
61.     function CoroutineManager.get_active_count()
62.         local count = 0
63.         for _ in pairs(CoroutineManager.active_coroutines) do
64.             count = count + 1
65.         end
66.         return count
67.     end
68.    
69.     -- 清理所有协程
70.     function CoroutineManager.clear()
71.         for id, co_data in pairs(CoroutineManager.active_coroutines) do
72.             -- 强制结束协程（仅用于清理）
73.             -- 注意：这不是一个安全的操作，实际应用中可能需要更优雅的处理方式
74.             CoroutineManager.active_coroutines[id] = nil
75.         end
76.         collectgarbage("collect")
77.     end
78.    
79.     -- 2. 创建示例任务
80.     local function sample_task(id, duration)
81.         print(string.format("任务%d开始，预计运行%d个周期", id, duration))
82.         
83.         for i = 1, duration do
84.             print(string.format("任务%d: 周期%d/%d", id, i, duration))
85.             coroutine.yield()
86.         end
87.         
88.         print(string.format("任务%d完成", id))
89.     end
90.    
91.     -- 3. 使用协程管理器
92.     -- 注册多个任务
93.     local task1_id = CoroutineManager.register(sample_task, 1, 3)
94.     local task2_id = CoroutineManager.register(sample_task, 2, 5)
95.     local task3_id = CoroutineManager.register(sample_task, 3, 2)
96.    
97.     print("初始活动协程数量:", CoroutineManager.get_active_count())
98.    
99.     -- 模拟多个更新周期
100.     for i = 1, 6 do
101.         print(string.format("\n--- 更新周期%d ---", i))
102.         CoroutineManager.update()
103.         print("当前活动协程数量:", CoroutineManager.get_active_count())
104.     end
105.    
106.     -- 清理
107.     CoroutineManager.clear()
108.     print("协程管理器已清理")
109. end
111. coroutine_lifecycle_management()

复制代码

7.2 内存监控与调试

2. -- 示例：协程内存监控与调试
3. local function coroutine_memory_monitoring()
4.     -- 内存监控工具
5.     local MemoryMonitor = {
6.         history = {},
7.         max_history = 100
8.     }
9.    
10.     -- 记录内存使用情况
11.     function MemoryMonitor.record()
12.         collectgarbage("collect")
13.         local mem_kb = collectgarbage("count")
14.         table.insert(MemoryMonitor.history, mem_kb)
15.         
16.         -- 保持历史记录在限制范围内
17.         if #MemoryMonitor.history > MemoryMonitor.max_history then
18.             table.remove(MemoryMonitor.history, 1)
19.         end
20.         
21.         return mem_kb
22.     end
23.    
24.     -- 获取内存使用趋势
25.     function MemoryMonitor.get_trend()
26.         if #MemoryMonitor.history < 2 then
27.             return "insufficient_data"
28.         end
29.         
30.         local first = MemoryMonitor.history[1]
31.         local last = MemoryMonitor.history[#MemoryMonitor.history]
32.         
33.         if last > first * 1.1 then
34.             return "increasing"
35.         elseif last < first * 0.9 then
36.             return "decreasing"
37.         else
38.             return "stable"
39.         end
40.     end
41.    
42.     -- 打印内存使用报告
43.     function MemoryMonitor.report()
44.         local trend = MemoryMonitor.get_trend()
45.         local current = MemoryMonitor.record()
46.         
47.         print("\n--- 内存使用报告 ---")
48.         print("当前内存使用:", string.format("%.2f KB", current))
49.         print("内存使用趋势:", trend)
50.         
51.         if trend == "increasing" then
52.             print("警告: 内存使用量正在增加，可能存在内存泄漏")
53.         end
54.     end
55.    
56.     -- 1. 记录初始内存
57.     MemoryMonitor.record()
58.     print("初始内存使用:", string.format("%.2f KB", MemoryMonitor.history[1]), "KB")
59.    
60.     -- 2. 创建一些协程并监控内存
61.     local coroutines = {}
62.    
63.     -- 创建10个简单协程
64.     for i = 1, 10 do
65.         coroutines[i] = coroutine.create(function()
66.             local data = string.rep("x", 1000)  -- 分配一些数据
67.             for j = 1, 5 do
68.                 coroutine.yield()
69.             end
70.         end)
71.         coroutine.resume(coroutines[i])
72.         
73.         -- 每创建一个协程后记录内存
74.         MemoryMonitor.record()
75.     end
76.    
77.     -- 3. 运行协程并监控内存
78.     for round = 1, 5 do
79.         print("\n--- 运行轮次", round, "---")
80.         for i, co in ipairs(coroutines) do
81.             if coroutine.status(co) ~= "dead" then
82.                 coroutine.resume(co)
83.             end
84.         end
85.         
86.         MemoryMonitor.record()
87.         MemoryMonitor.report()
88.     end
89.    
90.     -- 4. 清理协程并监控内存
91.     print("\n--- 清理协程 ---")
92.     coroutines = nil
93.     collectgarbage("collect")
94.    
95.     MemoryMonitor.record()
96.     MemoryMonitor.report()
97.    
98.     -- 5. 创建一个可能导致内存泄漏的场景
99.     print("\n--- 模拟内存泄漏场景 ---")
100.     local leaky_coroutines = {}
101.    
102.     for i = 1, 20 do
103.         -- 创建协程但不保存引用，理论上应该被GC回收
104.         coroutine.create(function()
105.             -- 创建一些数据
106.             local data = {}
107.             for j = 1, 100 do
108.                 data[j] = string.rep("y", 1000)
109.             end
110.             
111.             -- 无限循环，协程永远不会结束
112.             while true do
113.                 coroutine.yield()
114.             end
115.         end)
116.         
117.         MemoryMonitor.record()
118.     end
119.    
120.     MemoryMonitor.report()
121.    
122.     -- 6. 强制GC并查看结果
123.     print("\n--- 强制垃圾回收 ---")
124.     collectgarbage("collect")
125.     MemoryMonitor.record()
126.     MemoryMonitor.report()
127.    
128.     -- 注意：由于无限循环的协程仍然存在，内存可能不会完全释放
129.     -- 这是一个典型的内存泄漏场景
130. end
132. coroutine_memory_monitoring()

复制代码

7.3 综合示例：协程安全的资源管理

2. -- 示例：协程安全的资源管理
3. local function coroutine_safe_resource_management()
4.     -- 资源管理器
5.     local ResourceManager = {
6.         resources = {},
7.         resource_counter = 0,
8.         -- 使用弱值表来跟踪资源，避免阻止GC
9.         resource_tracking = setmetatable({}, {__mode = "v"})
10.     }
11.    
12.     -- 创建新资源
13.     function ResourceManager.create(data)
14.         ResourceManager.resource_counter = ResourceManager.resource_counter + 1
15.         local id = ResourceManager.resource_counter
16.         
17.         -- 创建资源对象
18.         local resource = {
19.             id = id,
20.             data = data,
21.             created_at = os.time(),
22.             ref_count = 0,
23.             -- 清理函数
24.             cleanup = function(self)
25.                 print(string.format("清理资源%d (数据: %s)", self.id, self.data))
26.                 ResourceManager.resources[self.id] = nil
27.             end
28.         }
29.         
30.         -- 存储资源
31.         ResourceManager.resources[id] = resource
32.         
33.         return resource
34.     end
35.    
36.     -- 获取资源（增加引用计数）
37.     function ResourceManager.acquire(id)
38.         local resource = ResourceManager.resources[id]
39.         if resource then
40.             resource.ref_count = resource.ref_count + 1
41.             return resource
42.         end
43.         return nil
44.     end
45.    
46.     -- 释放资源（减少引用计数）
47.     function ResourceManager.release(resource)
48.         if resource and ResourceManager.resources[resource.id] then
49.             resource.ref_count = resource.ref_count - 1
50.             if resource.ref_count <= 0 then
51.                 resource:cleanup()
52.             end
53.         end
54.     end
55.    
56.     -- 协程安全的资源使用包装器
57.     function ResourceManager.with_resource(id, func)
58.         local resource = ResourceManager.acquire(id)
59.         if not resource then
60.             error("资源不存在: " .. tostring(id))
61.         end
62.         
63.         -- 使用pcall确保资源总是被释放
64.         local success, result = pcall(func, resource)
65.         ResourceManager.release(resource)
66.         
67.         if not success then
68.             error(result)
69.         end
70.         
71.         return result
72.     end
73.    
74.     -- 1. 创建一些资源
75.     local res1 = ResourceManager.create("数据库连接")
76.     local res2 = ResourceManager.create("文件句柄")
77.     local res3 = ResourceManager.create("网络套接字")
78.    
79.     -- 2. 创建使用资源的协程
80.     local function resource_user_task(resource_id, task_name)
81.         print(string.format("任务'%s'开始，需要资源%d", task_name, resource_id))
82.         
83.         -- 使用with_resource确保资源正确释放
84.         ResourceManager.with_resource(resource_id, function(resource)
85.             print(string.format("任务'%s'正在使用资源%d (数据: %s)",
86.                                task_name, resource.id, resource.data))
87.             
88.             -- 模拟工作
89.             for i = 1, 3 do
90.                 print(string.format("任务'%s': 工作步骤%d", task_name, i))
91.                 coroutine.yield()
92.             end
93.             
94.             print(string.format("任务'%s'完成资源使用", task_name))
95.         end)
96.         
97.         print(string.format("任务'%s'完成", task_name))
98.     end
99.    
100.     -- 3. 创建协程
101.     local tasks = {
102.         coroutine.create(function() resource_user_task(res1.id, "数据处理任务") end),
103.         coroutine.create(function() resource_user_task(res2.id, "文件读写任务") end),
104.         coroutine.create(function() resource_user_task(res3.id, "网络通信任务") end),
105.         coroutine.create(function() resource_user_task(res1.id, "备份任务") end),
106.         coroutine.create(function() resource_user_task(res2.id, "日志任务") end)
107.     }
108.    
109.     -- 4. 运行协程直到所有完成
110.     local all_done = false
111.     local round = 0
112.    
113.     while not all_done do
114.         round = round + 1
115.         print(string.format("\n--- 执行轮次 %d ---", round))
116.         
117.         all_done = true
118.         for _, task in ipairs(tasks) do
119.             if coroutine.status(task) ~= "dead" then
120.                 coroutine.resume(task)
121.                 all_done = false
122.             end
123.         end
124.         
125.         -- 打印资源状态
126.         print("当前资源状态:")
127.         for id, resource in pairs(ResourceManager.resources) do
128.             print(string.format("  资源%d: 引用计数=%d", id, resource.ref_count))
129.         end
130.     end
131.    
132.     -- 5. 清理
133.     print("\n--- 最终清理 ---")
134.     for id, resource in pairs(ResourceManager.resources) do
135.         resource:cleanup()
136.     end
137.    
138.     print("资源管理完成")
139. end
141. coroutine_safe_resource_management()

复制代码

结论

Lua协程是一种强大的工具，但正确管理其内存使用至关重要。通过理解Lua的内存管理机制、识别常见的内存泄漏原因，并采用适当的管理策略，可以有效地避免内存泄漏问题。

关键要点包括：

1. 确保协程能够正常结束，避免无限循环的协程
2. 注意协程中的闭包和引用，避免不必要的引用阻止GC回收
3. 使用协程池等模式重用协程，减少创建和销毁的开销
4. 实施适当的监控和调试机制，及时发现内存问题
5. 使用资源管理器等模式确保资源正确释放

通过遵循这些最佳实践，可以充分利用Lua协程的强大功能，同时避免内存泄漏等常见问题。