Lua基础之coroutine（协程）

概括：1.创建协程2.coroutine的函数3.coroutine的基本流程4.yield对coroutine流程的干预5.resume, function()以及yield之间的参数传递和返回值传递

原文地址：http://blog.csdn.net/dingkun520wy/article/details/50212199

1.创建协程

协程和多线程下的线程类似：有自己的堆栈，自己的局部变量，有自己的指令指针，但是和其他协程程序共享全局变量等信息。线程和协程的主要不同在于：多处理器的情况下，概念上来说多线程是同时运行多个线程，而协程是通过协作来完成，任何时刻只有一个协程程序在运行。并且这个在运行的协程只有明确被要求挂起时才会被挂起。

 

--创建协程
co = coroutine.create(function ()
     print("hi")
end)
--启动协程
coroutine.resume(co)

2.coroutine的函数

 

 

(1) coroutine.create() 创建协程

(2) coroutine.resume()运行协程，可以向协程内传递参数

(3) coroutine.yield()挂起协程，可以向外传递参数

(4) coroutine.status()返回协程当前状态，coroutine的状态分为suspend, running, dead三种。

3.coroutine的基本流程

 

co = coroutine.create(function(a, b)
    print(coroutine.status(co), "start")   --执行代码，coroutine状态为running--->(3)
    print("co", a, b)
    print(coroutine.status(co), "end")    --执行代码，coroutine状态为running     --->(4)
end)

print(coroutine.status(co))       --刚创建的coroutine的状态为suspend   --->(1)
coroutine.resume(co, 1, 2)       --启动coroutine,将跳转到coroutine的function执行   --->(2)
print(coroutine.status(co))       --coroutine执行完毕，状态为dead    --->(5)

代码的执行结果如下：

 

suspended
running    start
co    1    2
running    end
dead

4.yield对coroutine流程的干预

yield作用是将一个running的coroutine挂起，相应的其状态就会被切换成suspend。在执行到yield之后，代码跳转到上一次resume代码的后一条代码执行，再次调用resume，代码就跳转到上一次yield代码的后一条代码执行。一般来说，resume方法在主线程中调用；而yield则是coroutine内调用，包括coroutine内部调用的函数内部。在coroutine中调用resume没有什么问题，但这样是没有什么意义的，因为如果代码还在coroutine中执行的话，则说明其状态一定是running的，这个时候的resume是没有任何意义的。而在主线程中调用yield，会导致 “lua: attempt to yield across metamethod/C-call boundary”的错误。

 

co = coroutine.create(function(a, b)
	print(coroutine.status(co), "start")				--->(2)
	for i = 1, 10 do
		print("co", a, b)								--->(3)(6)
		coroutine.yield()
		print(coroutine.status(co), "after yield")		--->(5)
	end
	print(coroutine.status(co), "end")
end)

print(coroutine.status(co))								--->(1)
coroutine.resume(co, 1, 2)
print(coroutine.status(co))								--->(4)
coroutine.resume(co, 1, 2)								
print(coroutine.status(co))								--->(7)

执行结果

 

suspended
runningstart
co12
suspended
runningafter yield
co12
suspended

5.resume, function()以及yield之间的参数传递和返回值传递

resume的参数除了coroutine句柄(第一个参数)以外，都传递给了function，关系跟表达式赋值是一致的，少的以nil补足，多的舍弃。

 

co1 = coroutine.create(function(a, b)
	print("co", a, b)
end)

co2 = coroutine.create(function(a, b)
	print("co", a, b)
end)

co3 = coroutine.create(function(a, b)
	print("co", a, b)
end)

coroutine.resume(co1, 1)
coroutine.resume(co2, 1, 2)
coroutine.resume(co3, 1, 2, 3)

 

执行结果如下：

 

co1nil
co12
co12

如果在coroutine中包含有yield,情况会复杂一些。

我们进一步挖掘coroutine的流程：

1 resume 

2 function

3 yield

4 yield挂起，第一次 resume返回

5 第二次resume

6 yield返回

7 function 继续执行

在这个流程的第一步的时候，resume的参数会传递给function,作为参数(具体如上)；到了第三步的时候，yield的参数会作为resume返回值的一部分；而第二次resume(第五步)的时候，resume的参数的作用发生了改变，resume的参数会传递给yield,做为yield的返回值。

这个过程很精巧，在coroutine执行的过程中返回，必然需要告诉外部现在coroutine这个时候的内部的的情况，通过唯一的接口yield的参数作为resume的返回值，高；到了第二次resume的时候，外部的环境必然发生了改变， 怎么通知coroutine内部呢，同样的想法，将唯一的接口resume的参数通过yield的返回的途径返回到coroutine内部，一样的高明。

贴一个引用的代码

 

function foo (a)
    print("foo", a)  -- foo 2
    return coroutine.yield(2 * a) -- return: a , b
end
 
co = coroutine.create(function (a , b)
    print("co-body", a, b) -- co-body 1 10
    local r = foo(a + 1)
     
    print("co-body2", r)
    local r, s = coroutine.yield(a + b, a - b)
     
    print("co-body3", r, s)
    return b, "end"
end)
        
print("main", coroutine.resume(co, 1, 10)) -- true, 4
print("------")
print("main", coroutine.resume(co, "r")) -- true 11 -9
print("------")
print("main", coroutine.resume(co, "x", "y")) -- true 10 end
print("------")
print("main", coroutine.resume(co, "x", "y")) -- false cannot resume dead coroutine
print("------")

结果如下：

 

co-body1 10
foo2
maintrue 4
------
co-body2r
maintrue 11-9
------
co-body3x y
maintrue 10end

------
mainfalse cannot resume dead coroutine
------