协程和线程类似，协程是一系列的可执行语句，拥有自己的栈、局部变量和指令指针，同时协程又与其他协程共享了全局变量和其他几乎一切资源。协程和线程的主要区别在于，一个多线程程序可以并行运行多个线程，而协程需要彼此协作的运行，即

在任意指定的时刻只能有一个协程运行

，且只有当正在运行的协程显式的要求被挂起时执行才会暂停。

Lua语言中协程相关的所有函数都被放在表 coroutine中，函数create用于创建新协程，该函数只有一个参数，即协程要执行的代码的函数。函数create返回一个” thread ＂类型的值，即新协程。

函数create 的参数可以是一个匿名函数：

> co=coroutine.create(function() print("hello,coroutine") end)
> print(co)
thread: 0x2609628
> print(type(co))
thread

一个协程有以下四种状态，即挂起（ spended ）、运行（ running） 、正常（ normal ）和死亡（ dead ），可以通过函数 coroutine.status 来检查协程的状态：

当一个协程被创建时，它处于挂起状态，即协程不会在被创建时自动运行。函数 coroutine.resume 用于启动或再次启动一个协程的执行，并将其状态由挂起改为运行。

> coroutine.resume(co)
hello,coroutine
true
> coroutine.status(co)
dead

协程运行完之后就会进入死亡状态，如果要在交互模式下运行上述代码 ，最好在最后一行加上一个分号来阻止输出函数 resume的返回值。

协程看上去也就是一种复杂的调用函数的方式，协程的真正强大之处在于函数 yield ，该函数可以让一个运行中的协程挂起自己，然后在后续恢复运行。

co=coroutine.create(function()
        for i=1,10 do
                print("co",i)
                coroutine.yield()
        end
end)

for i=0,10 do
        coroutine.resume(co)
        print(co,coroutine.status(co))
end
print(coroutine.resume(co))

co	1
thread: 0x1d493d8	suspended
co	2
thread: 0x1d493d8	suspended
co	3
thread: 0x1d493d8	suspended
co	4
thread: 0x1d493d8	suspended
co	5
thread: 0x1d493d8	suspended
co	6
thread: 0x1d493d8	suspended
co	7
thread: 0x1d493d8	suspended
co	8
thread: 0x1d493d8	suspended
co	9
thread: 0x1d493d8	suspended
co	10
thread: 0x1d493d8	suspended
thread: 0x1d493d8	dead
false	cannot resume dead coroutine

可以看到，在挂起期间发生的活动都发生在协程调用 yield 期间，当唤醒协程时，函数 yield 才会最终返回，然后协程会继续执行直到遇到下一个 yield 或执行结束。在最后一次调用 resume 时，协程体执行完毕并返回，不输出任何数据，如果试图再次唤醒它，函数resume 将返回 false和一条错误信息。

注意：函数 resume 也运行在保护模式中 因此，如果协程在执行中出错， Lua 语言不会显示错误信息，而是将错误信息返回给函数resume。

当协程A唤醒协程B时，协A既不是挂起状态（因为不能唤醒协程A），也不是运行状态（因为正在运行的协程是B）。所以，协程A此时的状态就被称为正常状态。

Lua 语言中一个非常有用的机制是通过一对 resume-yield 来交换数据；第一个 resume数（没有对应等待它的 yield ）会把所有的额外参数传递给协程的主函数。

co = coroutine.create(function (a, b, c) 
	print("co",a,b+1,c+2)
end) 
co outine.resume(co, 1, 2, 3) 

在函数 coroutine. esume 的返回值中，第一个返回值为true 表示没有错误，之后的返回值对应函数 yield 的参数。当一个协程运行结束时，主函数所返回的值都将变成对应函数 resume 的返回值。

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

coroutine.resume(co,"hello")
coroutine.resume(co,4,5);

协程最经典示例之一就是生产者－消费者问题。在生产者－消费者问题中涉及两个函数，一个函数不断地产生值，另一个函数不断的消费这些值。

示例，使用过滤器的生产者-消费者模型，过滤器位于生产者和消费者之间，用于完成一些对数据进行某种变换的任务。过滤器 filter 既是一个消费者又是一个生产者，它通过唤醒一个生产者来获得新值，然后又将变换后的值传递给消费者。在前面代码中添加一个过滤器以实现在每行的起始处插入行号。

function receive(prod)
		local status,value=coroutine.resume(prod)
        return value
end

function send(x)
        coroutine.yield(x)
end

function producer()
        return coroutine.create(function()
                while true do
                	local x=io.read()--new info
                    send(x)
                end
        end)
end

function filter(prod)
     return coroutine.create(function()
             for line=1,math.huge do
                 local x=receive(prod)
                 x=string.format("%5d %s",line,x)
                 send(x)
             end
     end)
end

function consumer(prod)
        while true do
             local x=receive(prod)
             io.write(x,"\n")
        end
end

consumer(filter(producer()))


代码的最后一行只是简单地创建出所需的各个组件，将这些组件连接在一起，然后启动消费者。

hello
    1 hello
world
    2 world
coroutine
    3 coroutine

    4 
let's go
    5 let's go


用协程来实现迭代器很合适，协程为实现这类任务提供了一种强大的工具；同时，协程最关键的特性是能够颠倒调用者与被调用者之间的关系。有了这种特性，在编写迭代器时就无须担心如何保存连续调用之间的状态了。

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)
                coroutine.yield(a)
        else
                for i=1,n do
                        -- 第i个元素当作最后一个
                        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)
        return coroutine.wrap(function() permgen(a) end)
--      local co=coroutine.create(function() permgen(a) end)
--      return function()--迭代函数
--              local code,res=coroutine.resume(co)
--              return res
--      end
end

--permgen({1,2,3,4,5})

for p in permutations{"a","b","c"} do
        printResult(p)
end



b c a 
c b a 
c a b 
a c b 
b a c 
a b c 

函数 permutations使用了 一种常见的模式，就是将唤醒对应协程的调用封装在一个函数中。wrap函数与函数create 类似，函数 wrap 也用来创建一个新的协程，但不同的是，函数 wrap 返回的不是协程本身而是一个函数，当这个函数被调用时会唤醒协程。与原始的函数resume 不同，该函数的第一个返回值不是错误代码，当遇到错误时该函数会抛出异常。

函数 coroutine. wrap 比函数 coroutine.create 更易于使用。

 不过，该函数缺乏灵活性，无法检查通过函数 wrap 所创建的协程的状态 ，也无法检查运行时的异常。

协程可以让我们使用事件循环来简化循环的代码，其核心思想是使用协程运行主要代码，即在每次调用库时将回调函数设置为唤醒协程的函数然后让出执行权。

实现一个在异步 I/O 库上运行传统同步代码的示例：

local cmdQueue={}

local lib={}

function lib.readline(stream,callback)
        local nextCmd=function()
                callback(stream:read())
        end
        table.insert(cmdQueue,nextCmd)
end

function lib.writeline(stream,line,callback)
        local nextCmd=function()
                callback(stream:write(line))
        end
        table.insert(cmdQueue,nextCmd)
end

function lib.stop()
        table.insert(cmdQueue,"stop")
end

function lib.runloop()
        while true do
                local nextCmd=table.remove(cmdQueue,1)
                if nextCmd=="stop" then
                        break
                else
                        nextCmd()
                end
        end
end

return lib


local lib =require "async-lib"

function run(code)
        local co=coroutine.wrap(function()
                code()
                lib.stop()      --结束时停止事件循环
        end)
local lib =require "async-lib"

function run(code)
        local co=coroutine.wrap(function()
                code()
                lib.stop()      --结束时停止事件循环
        end)
        co()    --启动协程
        lib.runloop()   --启动事件循环
end

function putline (stream, line)
        local co = coroutine.running() -- 调用协程
        local callback = (function () coroutine.resume(co) end)
        lib.writeline(stream, line, callback)
        coroutine.yield()
end

function getline (stream, line)
        local co = coroutine.running() -- 调用协程
        local callback = (function (l) coroutine.resume(co, l) end)
        lib.readline(stream, callback)
        local line = coroutine.yield()
        return line
end

run(function()
        local t={}
        local inp=io.input()
        local out=io.output()
        while true do
                local line=getline(inp)
                if not line then break end
                t[#t+1]=line
        end
        for i=#t,1,-1 do
                putline(out,t[i] .. "\n")
        end
end)


协程编程的奥秘：Lua中协程使用的全面解析与技巧分享

介绍了Lua语言中协程（coroutine）的基础概念、核心API及其在实际编程中的应用。协程是Lua中一种轻量级的并发模型，它通过非抢占式的协作机制，使得程序可以在单线程内实现多任务的协调处理。在Skynet等架构中，协程是最小的运行单元。

编程语言

后端

本文介绍Lua协程基础、生产者 - 消费者问题、作迭代器、事件驱动式编程及API说明。协程可挂起恢复，能交换数据，用于解决经典问题、实现迭代器、简化事件循环代码，其API涵盖创建、恢复等功能。

协程编程的奥秘：Lua中协程使用的全面解析与技巧分享

协程编程的奥秘：Lua中协程使用的全面解析与技巧分享

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐