Lua coroutine协程

coroutine:
coroutine.create 　　　--返回thread对象
coroutine.isyieldable
coroutine.resume　
coroutine.running  
coroutine.status
coroutine.wrap   　　 --返回function对象
coroutine.yield 

(1)coroutine.create (func)
　　传入一个函数参数，用来创建协程。返回一个“thread”对象。

(2)coroutine.isyieldable ()
　　如果正在运行的协程可以让出，则返回真。注意：只有主协程（线程）和C函数中是无法让出的。

(3)coroutine.resume (co [, val1, ···])
    用来启动或再次启动一个协程，使其由挂起状态变成运行状态。coroutine.resume函数相当于执行协程中的方法。参数Val1...是执行协程co时传递给协程的方法。
    首次执行协程co时，参数Val1...会传递给协程co的函数；
    再次执行协程co时，参数Val1...会作为给协程co中上一次yeild的返回值。

　　resume函数返回什么呢？有3种情况：
　　1）、如果协程co的函数执行完毕，协程正常终止，resume 返回 true和函数的返回值。
　　2）、如果协程co的函数执行过程中，协程让出了（调用了yeild()方法），那么resume返回true和协程中调用yeild传入的参数。
　　3）、如果协程co的函数执行过程中发生错误，resume返回false与错误消息。
　　可以看到resume无论如何都不会导致程序崩溃。它是在保护模式下执行的。



(4)coroutine.running ()
    用来判断当前执行的协程是不是主线程，如果是，就返回true。



(5)coroutine.status (co)
　　返回一个字符串，表示协程的状态。有4种状态：
　　1）、running。如果在协程的函数中调用status，传入协程自身的句柄，那么执行到这里的时候才会返回running状态。
　　2）、suspended。如果协程还未结束，即自身调用了yeild或还没开始运行，那么就是suspended状态。
　　3）、normal。如果协程A　resume协程B时，协程A处于的状态为normal。在协程B的执行过程中，协程A就一直处于normal状态。因为它这时候既不是挂起状态、也不是运行状态。
　　4）、dead。如果一个协程发生错误结束，或正常终止。那么就处于dead状态。如果这时候对它调用resume，将返回false和错误消息。

(6)coroutine.wrap (f)
　　wrap()也是用来创建协程的。只不过这个协程的句柄是隐藏的。跟create()的区别在于：
　　1）、wrap()返回的是一个函数，每次调用这个函数相当于调用coroutine.resume()。
　　2）、调用这个函数相当于在执行resume()函数。
　　3）、调用这个函数时传入的参数，就相当于在调用resume时传入的除协程的句柄外的其他参数。
　　4）、调用这个函数时，跟resume不同的是，它并不是在保护模式下执行的，若执行崩溃会直接向外抛出。

(7)coroutine.yield (···)
　　使正在执行的函数挂起，可以传入变长参数。

#!/usr/local/bin/lua

function func(a, b)
        while a > 0 do
                print(a + b)
                print("running:", coroutine.isyieldable())
                a = a-1

                if a < 50 then
                        y = coroutine.yield(80, 2)
                        print(y)
                end
        end
end


co1 = coroutine.create(func)
print(co1)

print(coroutine.status(co1))
coroutine.resume(co1, 100, 1)
print(coroutine.status(co1))                      

#!/usr/local/bin/lua
co2 = coroutine.wrap(function (a, b)
    print("resume :", a, b)
    ret = coroutine.yield()
    print("ret:", ret)
end)

print(type(co2))
print(co2)
co2(2,3)
co2(88)

--程序运行结果
function
function: 0x135b6c0
resume :    2   3
ret:    88

function foo(a)
    print("foo", a)
    return coroutine.yield(2 * a)
end

co = coroutine.create(function ( a, b )
    print("co-body", a, b)
    local r = foo(a + 1)
    print("co-body", r)
    local r, s = coroutine.yield(a + b, a - b)
    print("co-body", r, s)
    return b, "end"
end)

print("main", coroutine.resume(co, 1, 10))
print("main", coroutine.resume(co, "r"))
print("main", coroutine.resume(co, "x", "y"))
print("main", coroutine.resume(co, "x", "y"))

例程：

#!/usr/local/bin/lua

print("========coroutine.create==============")
function f(a, b, c)
    print("a + b + c=", a+b+c)
end

co = coroutine.create(f)
print(type(co))
print(co)
print(coroutine.resume(co, 2, 4, 6))
print(coroutine.status(co))

print("========coroutine.wrap==========")
function g(a, b ,c)
    print("a * b * c=", a*b*c)
end

co1 = coroutine.wrap(g)
print(type(co1))
print(co1)
print(co1(2,3,4))


--程序运行结果
========coroutine.create==============
thread
thread: 0x1475638
a + b + c=  12
true
dead
========coroutine.wrap==========
function
function: 0x147cbe0
a * b * c=  24