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

线程和协同程序的主要不同在于：在多处理器情况下，多线程程序同时运行多个线程；而协同程序是通过协作来完成，在任一指定时刻只有一个协同程序在运行，并且这个正在运行的协同程序只在必要时才会被挂起。这样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)endco = 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    10foo    2---main---    true    4co-body_02    r7---main---    true    11    -9co-body_03    x    y---main---    true    10    end---main---    false    cannot resume dead coroutine

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

co-body_01 1 10foo    2main    false    D:\UserProfiles\Jeff\Desktop\t_corotine.lua:13: attempt to index local ‘a‘ (a number value)main    false    cannot resume dead coroutinemain    false    cannot resume dead coroutinemain    false    cannot resume dead coroutine[Finished in 0.1s]

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

（二）用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

Lua 协程coroutine

声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉：投诉/举报工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。

联系
我们

首页 > 代码库 > Lua 协程coroutine

Lua 协程coroutine

（一）Coroutine 基础

（二）用coroutine实现迭代器

看完仍有疑问？有类似问题直接问程序猿