Lua中的协同程序 coroutine

Lua中的协程和多线程很相似，每一个协程有自己的堆栈，自己的局部变量，可以通过yield-resume实现在协程间的切换。不同之处是：Lua协程是非抢占式的多线程，必须手动在不同的协程间切换，且同一时刻只能有一个协程在运行。并且Lua中的协程无法在外部将其停止，而且有可能导致程序阻塞。

一、基本环境：

Microsoft Windows XP/Service Pack 2

Lua 5.1.4  Copyright (C) 1994-2008 Lua.org, PUC-Rio


二、 coroutine的接口：

(1) coroutine.create()

(2) coroutine.resume()

(3) coroutine.yield()

(4) coroutine.status()

(5) coroutine.wrap()

(6) coroutine.running()


三、coroutine的状态分为suspend, running, dead三种。


四、coroutine的基本流程

下面的代码说明了coroutine的基本流程

[plain] view plain copy
  1. co = coroutine.create(function(a, b)  
  2.     print(coroutine.status(co), "start")   --执行代码，coroutine状态为running--->(3)  
  3.     print("co", a, b)  
  4.     print(coroutine.status(co), "end")    --执行代码，coroutine状态为running     --->(4)  
  5. end)  
  6.   
  7. print(coroutine.status(co))       --刚创建的coroutine的状态为suspend   --->(1)  
  8. coroutine.resume(co, 1, 2)       --启动coroutine,将跳转到coroutine的function执行   --->(2)  
  9. print(coroutine.status(co))       --coroutine执行完毕，状态为dead    --->(5)  

代码的执行结果如下：

[plain] view plain copy
  1. >lua -e "io.stdout:setvbuf 'no'" "cur.lua"   
  2. suspended  
  3. running    start  
  4. co    1    2  
  5. running    end  
  6. dead  
  7. >Exit code: 0  


五、yield对coroutine流程的干预

如果没有yield，coroutine的生老病死就是上面这样一个流程了。

接下来轮到yield出场，它的作用是将一个running的coroutine挂起，相应的其状态就会被切换成suspend。

先贴代码，再解释

[plain] view plain copy
  1. co = coroutine.create(function(a, b)  
  2.     print(coroutine.status(co), "start")                --->(2)  
  3.     for i = 1, 10 do  
  4.         print("co", a, b)                               --->(3)(6)  
  5.         coroutine.yield()  
  6.         print(coroutine.status(co), "after yield")      --->(5)  
  7.     end  
  8.     print(coroutine.status(co), "end")  
  9. end)  
  10.   
  11. print(coroutine.status(co))                             --->(1)  
  12. coroutine.resume(co, 1, 2)  
  13. print(coroutine.status(co))                             --->(4)  
  14. coroutine.resume(co, 1, 2)                                
  15. print(coroutine.status(co))                             --->(7)  

执行结果贴一下：

[plain] view plain copy
  1. >lua -e "io.stdout:setvbuf 'no'" "cur.lua"   
  2. suspended  
  3. running start  
  4. co  1   2  
  5. suspended  
  6. running after yield  
  7. co  1   2  
  8. suspended  
  9. >Exit code: 0  

在执行到yield之后，代码跳转到上一次resume代码的后一条代码执行

再次调用resume，代码就跳转到上一次yield代码的后一条代码执行。

一般来说，resume方法在主线程中调用；而yield则是在coroutine内调用，包括coroutine内部调用的函数内部。

当然了，在coroutine中调用resume没有什么问题，但这样是没有什么意义的，因为如果代码还在coroutine中执行的话，则说明其状态一定是running的，这个时候的resume是没有任何意义的。而在主线程中调用yield，会导致 “lua: attempt to yield across metamethod/C-call boundary”的错误。


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

[plain] view plain copy
  1. co1 = coroutine.create(function(a, b)  
  2.     print("co", a, b)  
  3. end)  
  4.   
  5. co2 = coroutine.create(function(a, b)  
  6.     print("co", a, b)  
  7. end)  
  8.   
  9. co3 = coroutine.create(function(a, b)  
  10.     print("co", a, b)  
  11. end)  
  12.   
  13. coroutine.resume(co1, 1)  
  14. coroutine.resume(co2, 1, 2)  
  15. coroutine.resume(co3, 1, 2, 3)  

执行结果如下：

[plain] view plain copy
  1. >lua -e "io.stdout:setvbuf 'no'" "cur.lua"   
  2. co  1   nil  
  3. co  1   2  
  4. co  1   2  
  5. >Exit code: 0  


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

如果在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内部，一样的高明。

贴一个引用的代码，代码源出处见参考：

[plain] view plain copy
  1. function foo (a)  
  2.     print("foo", a)  -- foo 2  
  3.     return coroutine.yield(2 * a) -- return: a , b  
  4. end  
  5.    
  6. co = coroutine.create(function (a , b)  
  7.     print("co-body", a, b) -- co-body 1 10  
  8.     local r = foo(a + 1)  
  9.        
  10.     print("co-body2", r)  
  11.     local r, s = coroutine.yield(a + b, a - b)  
  12.        
  13.     print("co-body3", r, s)  
  14.     return b, "end"  
  15. end)  
  16.           
  17. print("main", coroutine.resume(co, 1, 10)) -- true, 4  
  18. print("------")  
  19. print("main", coroutine.resume(co, "r")) -- true 11 -9  
  20. print("------")  
  21. print("main", coroutine.resume(co, "x", "y")) -- true 10 end  
  22. print("------")  
  23. print("main", coroutine.resume(co, "x", "y")) -- false cannot resume dead coroutine  
  24. print("------")  

结果如下：

[plain] view plain copy
  1. >lua -e "io.stdout:setvbuf 'no'" "cur.lua"   
  2. co-body 1   10  
  3. foo 2  
  4. main    true    4  
  5. ------  
  6. co-body2    r  
  7. main    true    11  -9  
  8. ------  
  9. co-body3    x   y  
  10. main    true    10  end  
  11. ------  
  12. main    false   cannot resume dead coroutine  
  13. ------  
  14. >Exit code: 0  

刚看有点绕，大家静心看看， 必有收获，毕竟代码不长。

参考：

1 programming in Programming in Lua

2 lua-5.1中文手册

3 http://www.cnblogs.com/yjf512/archive/2012/05/28/2521412.html

posted @ 2016-09-06 11:02  何人之名  阅读(162)  评论(0)    收藏  举报