lua coroutine
Lua中协程都放在表coroutine中。
Lua协程的四个状态
- 挂起(suspended)：一个协程被创建的时候，处于挂起状态，不会自动运行。
- 运行(running)：coroutine.resume()用于启动或者再次启动一个协程，使其变成运行状态。
- 正常(normal)：协程A唤醒协程B的时候，协程B处于运行状态，协程A就处于正常状态。
- 死亡(dead)：协程中包含的函数执行完毕，协程就变成了死亡状态。
Lua协程的操作函数：
创建协程：coroutine.create(func)
该函数接受一个函数作为参数，返回一个thread类型的值。
例如：
local co = coroutine.create(function() print("hello") end)
print(type(co))
输出：
thread
启动协程：coroutine.resume(co, arg1, arg2, ...)
参数：可以分为两种情况。
1.协程中不包含yield()：第一个参数是被启动的协程，后面的参数传递给协程封装的函数作为参数。
例如：
local co = coroutine.create(
function(a, b)
print("a + b =", a + b)
end
)
coroutine.resume(co, 1, 2)
输出：
a + b = 3
2.协程中包含yield()：第一个参数还是被启动的线程，在首次调用resume时，后面的参数传递给协程封装的函数作为参数；而再次调用（非首次）resume()时，后面的参数将作为yield()的返回值。
例如：
local co = coroutine.create(
function(x)
print("co1", x)
print("co2", coroutine.yield())
end
)
coroutine.resume(co, "hello")
coroutine.resume(co, "world")
输出：
co1 hello
co2 world
返回值：分为三种情况。
1.协程没有结束，resume()第一个返回值是true，后面的返回值是yield(...)中的参数。
2.协程结束时，resume()第一个返回值是true，后面的返回值是协程中函数的返回值。
3.协程结束后，此时不应该继续调用resume，如果调用了，resume()第一个返回值是false，表示调用失败，第二个返回值是报错信息。
例如：
local co = coroutine.create(
function()
coroutine.yield("hello", "world")
return "hello", "lua"
end
)
print(coroutine.resume(co))
print(coroutine.resume(co))
print(coroutine.resume(co))
输出：
true hello world
true hello lua
false cannot resume dead coroutine
值得注意的是，resume运行在保护模式中，如果协程在执行过程中遇到了错误，Lua不会打印错误信息，而是把错误信息作为resume()的返回值。
挂起协程：coroutine.yield(arg1, arg2, ...)
参数：yield()将作为本次唤醒协程的resume()的返回值。
返回值：下次唤醒协程的resume()的参数，将作为yield()的返回值。
例如：
local co = coroutine.create(
function()
local ret = coroutine.yield("hello")
print(ret)
end
)
local state, ret = coroutine.resume(co)
print(state)
print(ret)
coroutine.resume(co, "world")
输出：
true
hello
world
Lua协程的特点
Lua协程是一种非对称协程（asymmetric coroutine）,需要两个函数来控制协程的执行，一个用于挂起协程，一个用于恢复协程。
相对于其他语言提供的对称协程（symmetric coroutine），只提供一个函数用于切换不同协程之间的控制权。
Lua协程的一些应用
1.生产者消费者问题：
1.消费者驱动型
-- 消费者驱动型 consumer-driven
producer_co = coroutine.create(
function()
for i = 1, 5 do
print("produce:", i)
coroutine.yield(i)
end
end
)
function consumer()
while true do
local status, value = coroutine.resume(producer_co)
print("producer:", coroutine.status(producer_co))
if not value then
break
end
print("consume:", value)
end
end
consumer()
输出：
produce: 1
producer: suspended
consume: 1
produce: 2
producer: suspended
consume: 2
produce: 3
producer: suspended
consume: 3
produce: 4
producer: suspended
consume: 4
produce: 5
producer: suspended
consume: 5
producer: dead
2.生产者驱动型
-- 生产者驱动型 producer-driven
function producer()
for i = 1, 5 do
print("produce:", i)
coroutine.resume(consumer_co, i)
print("consumer:", coroutine.status(consumer_co))
end
coroutine.resume(consumer_co)
end
consumer_co = coroutine.create(
function(x)
while true do
print("consume:", x)
x = coroutine.yield()
if not x then
break
end
end
end
)
producer()
print("consumer:", coroutine.status(consumer_co))
输出：
produce: 1
consume: 1
consumer: suspended
produce: 2
consume: 2
consumer: suspended
produce: 3
consume: 3
consumer: suspended
produce: 4
consume: 4
consumer: suspended
produce: 5
consume: 5
consumer: suspended
consumer: dead
2.将协程用作迭代器：
-- 产生全排列的迭代器
function permutation_gen(a, n)
n = n or #a
if n < 1 then
coroutine.yield(a)
else
for i = 1, n do
a[n], a[i] = a[i], a[n]
permutation_gen(a, n - 1)
a[n], a[i] = a[i], a[n]
end
end
end
function permutations(a)
local co = coroutine.create(function() permutation_gen(a) end)
return function()
local code, res = coroutine.resume(co)
return res
end
end
function permutations_wrap(a)
return coroutine.wrap(function() permutation_gen(a) end)
end
for p in permutations({1, 2, 3}) do
for i = 1, #p do io.write(p[i], " ") end
io.write("\n")
end
print("----")
for p in permutations_wrap({1, 2, 3}) do
for i = 1, #p do io.write(p[i], " ") end
io.write("\n")
end
输出：
2 3 1
3 2 1
3 1 2
1 3 2
2 1 3
1 2 3
----
2 3 1
3 2 1
3 1 2
1 3 2
2 1 3
1 2 3
其中coroutine.warp(func)方法就是创建一个封装func的协程，然后返回一个调用该协程的函数。
