【Lua】Coroutine 协程和闭包学习

Coroutine 协程学习

协程：通过显式调用 coroutine.create 函数来创建一个协程，把一个函数作为协程主体来执行。当我们启动 (resume) 协程时，它开始运行函数体并且直到结束或者让出控制权 (yield) ；一个协程只有通过显式调用 yield 函数才会中断。以后，我们可以 resume 它，它将会从它停止的地方继续执行。

一、status：supended、running、dead

二、方法：

• coroutine.resume() 唤醒：
  1、正常退出，coroutine.resume返回true
  2、异常发生错误，coroutine.resume返回false

• coroutine.yield() 挂起：但yield在协程被挂起时可以返回值，而return只有协程结束才能有返回值

• coroutine.create() 创建之后，协程的状态是挂起的

• coroutine.wrap方法：不可以使用status和resume方法

• coroutine.running返回正在跑的coroutine

• coroutine.status(coroutine.running(co))

三、方法学习：

1、resume与yield相互传数据

local function yieldFun(x, y)
	coroutine.yield(x * y, x / y) -- 协程挂起时，返回resume
	return x * y, x - y -- 协程结束时，返回resume
end

local co2 = coroutine.create(yieldFun)
print(coroutine.resume(co2, 10, 20)) -- 200 0.5
print(coroutine.resume(co2, 20, 40)) -- 200 -10  （20 40 未传入）
print(coroutine.resume(co2))

resume第一次发的 10 20 发给的yield所在的函数yieldFun作参数，第二次发给的yield的返回值，因为这里没有两次yield所以传不进去
yield发给的当前这次resume作返回值，return返回给第二个resume

2、wrap方法

local co1 = coroutine.wrap(function(input)
	print("inpput:", input)
	print("yield", coroutine.yield("sus"))
	return "end"
end)
--print(coroutine.resume(co1)) -- error ; wrap()不能直接使用resume
print("step1 : ", co1("123"))
print("step2 : ", co1("456"))

3、开另外一个协程

local co4 = coroutine.create(function()
	print("co4 start")
	print(coroutine.running())
end)
local co3 = coroutine.create(function() 
	print("co3 start")
	coroutine.resume(co4)
	coroutine.yield(co3)
end)
coroutine.resume(co3)

4、综合：其实做一个在死循环里面相互调用的情况，其中，resume向yield传了两次不一样的值，第一次给funYield做参数，后面五次发给coroutine.yield(t)的返回值，判断次数id来控制yield调用，然后判断status跳出

function funYield(t)
	print("fun")
	while t >= 0 do
		print("funYield : ", t)	
		print("coroutine:", coroutine.running(co), coroutine.status(coroutine.running(co)))
		t = coroutine.yield(t)
	end
	return "end"
end

local co = coroutine.create(funYield)
print(coroutine.running(co))
print(coroutine.resume(co, 10))
id = 5
while true do
	print(coroutine.resume(co, id))
	print("status:", coroutine.status(co))
	if "dead" ==  coroutine.status(co) then
		break
	end
	id = id - 1
end
print(coroutine.resume(co))
print(coroutine.running(co))

5、根据4的情况+了闭包的使用，主要是全局变量换成局部变量，学习了闭包，在闭包创建时，它调用luaF_findupval时，会去找upvalue的链表里面有复用的upvalue（否则新建），主要是非局部变量upvalue，问题是如何申请一个背包，fun indexFun 里面返回的是 fun 匿名函数 ，indexFun 引起了匿名函数 的局部变量。

function indexFun()
	local x = 3
	return function()
		x = x - 1
		return x
	end
end
function funYield(t)
	print("fun")
	while t >= 0 do
		print("funYield : ", t)	
		print("coroutine:", coroutine.running(co), coroutine.status(coroutine.running(co)))
		coroutine.yield(t)
	end
	return "end"
end

local co = coroutine.create(funYield)

print(coroutine.running(co))
print(coroutine.resume(co, 3))
local tempFun = indexFun()
while true do
	local id = tempFun()
	print("index:", id)
	print(coroutine.resume(co, id))
	print("status:", coroutine.status(co))
	if "dead" ==  coroutine.status(co) then
		break
	end
	if id <= 0  then
		break
	end
end
print(coroutine.resume(co))
print(coroutine.running(co))

还有个尾调用的概念：在f(x)函数结尾调用g(x)【类似goto】无论调用多少次都不会导致栈溢出，g(x)结束不返回
闭包学习参考：https://www.cnblogs.com/freebird92/p/6764357.html

四、备注：

skynet与正常的coroutine：
1、如果skynet的coroutine与正常的coroutine混用 所有的skynet阻塞接口触发yield
2、skynet状态加了一个类型 ：blocked（其实是normal的一个特例） 即当前coroutine被底层框架挂起，但不可以由引用框架resume 唤起
3、而在使用skynet的过程中，一般不经常直接使用coroutine模块，skynet本身提供了skynet.fork()来创建协程，可以用skynet.wait(co)来挂起，skynet.wakeup(co)来唤醒。wakeup只向skynet发了一个信号，需要等skynet框架来调度，而coroutine.resume会直接延续挂起的协程，一般coroutine模块应用：把coroutine当迭代器来使用