Lua 协程coroutine

  1. 云栖社区>
  2. 博客>
  3. 正文

Lua 协程coroutine

jeffjade 2014-11-24 19:50:00 浏览925
展开阅读全文

  协程和一般多线程的区别是,一般多线程由系统决定该哪个线程执行,是抢占式的,而协程是由每个线程自己决定自己什么时候不执行,并把执行权主动交给下一个线程。 协程是用户空间线程,操作系统其存在一无所知,所以需要用户自己去做调度,用来执行协作式多任务非常合适。

  线程和协同程序的主要不同在于:在多处理器情况下,多线程程序同时运行多个线程;而协同程序是通过协作来完成,在任一指定时刻只有一个协同程序在运行,并且这个正在运行的协同程序只在必要时才会被挂起。这样Lua的协程就不能利用现在多核技术了。

(一)Coroutine 基础

  Lua 协程有三个状态:挂起态(suspended)、运行态(running)、停止态(dead)。可以通过coroutine.status来查看协程出于神马状态。

Lua所支持的协程全称被称作协同式多线程(collaborative multithreading)。Lua为每个coroutine提供一个独立的运行线路。然而和多线程不同的地方就是,coroutine只有在显式调用yield函数后才被挂起,同一时间内只有一个协程正在运行。

Lua将它的协程函数都放进了coroutine这个表里,其中主要的函数如下

                                         

创建一个协程需要调用coroutine.create 。它只接收单个参数,这个参数是 coroutine 的主函数。 create 函数仅仅创建一个新的coroutine 然后返回一个类型为thread的对象,并不会启动 coroutine 的运行。
>hxc = coroutine.create(function () print("hi coroutine") end)
>print(type(hxc))                     -->thread
>print(coroutine.status(hxc))     -->suspended
>coroutine.resume(co)              -->  hi coroutine ;函数coroutine.resume使协同程序由挂起状态变为运行态,执行完毕协程进入dead状态
>print(coroutine.status(hxc))     -->dead

调 用 coroutine.resume 时,传入的第一个参数就是 coroutine.create 的返回值。这时,coroutine 从主函数的第一行开始运行。接下来传入 coroutine.resume 的参数将被传进 coroutine 的主函数。在 coroutine 开始运行后,运行到自身终止或是遇到一个 yield调用,这个yield函数是协程特别之处,它可以将正在运行的代码挂起。
hxc = coroutine.create(function ()
    for i=1,10 do
       print("iter", i)
       coroutine.yield()
    end
end)
执行这个协同程序,程序将在第一个yield处被挂起:
coroutine.resume(hxc)         --> iter 1
print(coroutine.status(hxc))  --> suspended
执行
coroutine.resume(hxc)         --> iter 2;resume激活被挂起的程序,将从函数yield的位置继续执行程序,直到再次遇到yield或程序结束。

Lua中协同可以通过resume-yield来交换数据。
1)通过resume把参数传递给协同的主程序。
hxc = coroutine.create(function (a,b)
    print("hxc", a,b,c)
end)
coroutine.resume(hxc, 1, 2)                  --> hxc 1 2
2)数据通过yield传给resume。true表明调用成功,true之后的部分,即是yield的参数。
hxc = coroutine.create(function(a,b)
    coroutine.yield(a + b, a - b)
end)
print(coroutine.resume(hxc, 20, 10))      --> true 30 10
或者把resume的参数,会被传递给yield。
hxc = coroutine.create (function ()
    print("hxc", coroutine.yield())
end)
coroutine.resume(hxc)
coroutine.resume(hxc, 4, 5)                   --> hxc 4 5
3)yield也会把多余的参数返回给对应的resume,如下:

co = coroutine.create(function()
    print("co", coroutine.yield())
  end)

coroutine.resume(co)
coroutine.resume(co , "oo" , "xx")

输出结果是:co oo xx ()      --[为何第一个resume没有任何输出呢? 答案是,yield没有返回,print就根本还没运行。]

4)当一个coroutine结束的时候,main函数的所有返回值都被返回给resume:

co = coroutine.create(function()
    return "ok", "no"
  end)
print(coroutine.resume(co))

输出结果是:true ok no

  协程的用途最明显的地方是需要访问某个异步的功能时,C语言常采用回调的方法:当异步完成时,回调脚本的一个已知的函数。如果程序执行到异步点时,跳回,当异步完成后,再回到跳回点继续执行。我的理解就是协程是把异步过程,当作同步处理(因此 也可将一些耗时的操作放置在coroutine中进行,也不至于耽搁其他逻辑的运行)。
 
  摘取一段云风的代码来详尽解释协程的工作机制,在这段代码中,展示了main thread和协程co之间的交互:
function foo(a)
    print("foo", a)
    -- a[1] = 3
    return coroutine.yield(2 * a)
end

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

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

运行结果如下:

co-body_01    1    10
foo    2
---main---    true    4
co-body_02    r7
---main---    true    11    -9
co-body_03    x    y
---main---    true    10    end
---main---    false    cannot resume dead coroutine

倘若将“-- a[1] = 3”  这一行注释打开,运行则是这样的:

co-body_01 1 10
foo    2
main    false    D:\UserProfiles\Jeff\Desktop\t_corotine.lua:13: attempt to index local 'a' (a number value)
main    false    cannot resume dead coroutine
main    false    cannot resume dead coroutine
main    false    cannot resume dead coroutine

[Finished in 0.1s]

corotine如此这般作用,也使得有些童鞋可以将该功用 当作Xpcall抑或是pcall使用;将易出错的代码写在协程内,即便出错也不会是的程序崩溃;

(二)coroutine的和callback的比较

  coroutine经常被用来和callback进行比较,因为通常来说,coroutine和callback可以实现相同的功能,即异步通信,比如说下面的这个例子:

bob.walkto(jane)
bob.say("hello")
jane.say("hello")

看起来好像是对的,但实际上由于这几个动作walkto,say都是需要一定时间才能做完的,所以这段程序如果这样写的话,就会导致bob一边走一边对jane说hello,然后在同时jane也对bob说hello,导致整个流程十分混乱。

如果使用回调来实现的话,代码示例如下:

bob.walto(function (  )
    bob.say(function (  )
        jane.say("hello")
    end,"hello")
end, jane)

即walto函数回调say函数,say函数再回调下一个say函数,这样回调看起来十分混乱,让人无法一下看出这段代码的意义.

如果用coroutine的话,可以使用如下写法:

co = coroutine.create(function (  )
    local current = coroutine.running
    bob.walto(function (  )
        coroutine.resume(current)
    end, jane)
    coroutine.yield()
    bob.say(function (  )
        coroutine.resume(current)
    end, "hello")
    coroutine.yield()
    jane.say("hello"end)

coroutine.resume(co)

在上述代码中,一旦一个异步函数被调用,协程就会使用coroutine.yield()方法将该协程暂时悬挂起来,在相应的回调函数中加上coroutine.resume(current),使其返回目前正在执行的协程中。

但是,上述代码中有许多重复的地方,所以可以通过将封装的方式将重复代码封装起来:

function runAsyncFunc( func, ... )
    local current = coroutine.running
    func(function (  )
        coroutine.resume(current)
    end, ...)
    coroutine.yield()
end

co = coroutine.create(function (  )
    runAsyncFunc(bob.walkto, jane)
    runAsyncFunc(bob.say, "hello")
    jane.say("hello")
end)

coroutine.resume(co)
coroutine.resume(co)
coroutine.resume(co)

这样就不需要改变从前的所有回调函数,即可通过携程的方式解决异步调用的问题,使得代码的结构非常清晰。

(三)用coroutine实现迭代器

  可以把迭代器 循环看成是一个特殊的producer-consumer例子:迭代器produce,循环体consume。下面我们就看一下coroutine为我们提供的强大的功能,用coroutine来实现迭代器。

我们来遍历一个数组的全排列。先看一下普通的loop实现,代码如下:

function printResult(a)  
    for i = 1, #a do  
        io.write(a[i], ' ')  
    end   
    io.write('\n')  
end  
   
function permgen(a, n)                                                                                                               
    n = n or #a  
    if n <= 1 then  
        printResult(a)  
    else  
        for i = 1, n do  
            a[n], a[i] = a[i], a[n]  
            permgen(a, n-1)  
            a[n], a[i] = a[i], a[n]  
        end   
    end   
end  
   
permgen({1,2,3})

再看一下迭代器实现,注意比较下代码的改变的部分:

function printResult(a)
    for i = 1, #a do
        io.write(a[i], ' ')
    end 
    io.write('\n')
end  
        
function permgen(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]
            permgen(a, n-1)
            a[n], a[i] = a[i], a[n]
        end 
    end 
end  
        
function permutations(a)
    local co = coroutine.create(function () permgen(a) end)                                                                        
    return function ()
        local code, res = coroutine.resume(co)
        return res 
    end 
end  
        
for p in permutations({"a", "b", "c"}) do
    printResult(p)
end 

permutations 函数使用了一个Lua中的常规模式,将在函数中去resume一个对应的coroutine进行封装。Lua对这种模式提供了一个函数coroutine.wap 。跟create 一样,wrap 创建一个新的coroutine ,但是并不返回给coroutine,而是返回一个函数,调用这个函数,对应的coroutine就被唤醒去运行。跟原来的resume 不同的是,该函数不会返回errcode作为第一个返回值,一旦有error发生,就退出了(类似C语言的assert)。使用wrap, permutations可以如下实现:

function permutations (a)
    return coroutine.wrap(function () permgen(a) end)
end

wrap 比create 跟简单,它实在的返回了我们最需要的东西:一个可以唤醒对应coroutine的函数。 但是不够灵活。没有办法去检查wrap 创建的coroutine的status, 也不能检查runtime-error(没有返回errcode,而是直接assert)。

参考文章: Here  and  Here

倾城之链 | NICE LINKS DJI Mavic Air

网友评论

登录后评论
0/500
评论
jeffjade
+ 关注