深入理解lua的协程coroutine

转自:https://blog.csdn.net/yzf279533105/article/details/79982139

1. 概述

lua协程和多线程

相同之处:拥有自己独立的桟、局部变量和PC计数器,同时又与其他协程共享全局变量和其他大部分东西

不同之处:一个多线程程序可以同时运行几个线程(并发执行、抢占),而协程却需要彼此协作地运行,并非真正的多线程,即一个多协程程序在同一时间只能运行一个协程,并且正在执行的协程只会在其显式地要求挂起(suspend)时,它的执行才会暂停(无抢占、无并发)。注意:由于Lua中的协程无法在外部将其停止,而且有可能导致程序阻塞

2. 函数介绍

Lua中所有与协程相关的函数都在coroutine(一个table)中,其中主要的函数如下

其他函数:

2.1 coroutine.isyieldable()    :    如果正在运行的协程可以让出,则返回true。值得注意的是,只有主协程(线程)和C函数中是无法让出的

2.2 coroutine.wrap()           :    wrap()也是用来创建协程的

只不过这个协程的句柄是隐藏的。跟create()的区别在于:

(1)、wrap()返回的是一个函数,每次调用这个函数相当于调用coroutine.resume()。

(2)、调用这个函数相当于在执行resume()函数。

 

 

(3)、调用这个函数时传入的参数,就相当于在调用resume时传入的除协程的句柄外的其他参数。

 

 

(4)、调用这个函数时,跟resume不同的是,它并不是在保护模式下执行的,若执行崩溃会直接向外抛出

    wrap()函数的示例代码:

co = coroutine.wrap(    function (a,b)
                        print("resume args:"..a..","..b)
                    yreturn = coroutine.yield()
                    print ("yreturn :"..yreturn)
             end
           )
print(type(co))
co(11,22)
co(33)
    结果如下:

function
resume args:11,22
yreturn :33
特别注意:

1. coroutine.resume()函数

用来首次启动或再次启动一个协程,使其由挂起状态变成运行状态。也可以这么说,resume函数相当于在执行协程中的方法。参数Val1...是执行协程co时传递给协程的参数。
(1) 首次调用resume执行协程co时,参数Val1...会赋值给协程co的函数,作为函数参数

(2) 以后再调用resume执行协程co时,参数Val1...会赋值给协程co中上一次yield的返回值

resume函数的返回有3种情况:

(1) 如果协程co的函数执行完毕,协程正常终止,resume 返回 true和函数的返回值。

(2) 如果协程co的函数执行过程中,协程让出了(调用了yield()方法),那么resume返回true和协程中调用yield传入的参数。

(3) 如果协程co的函数执行过程中发生错误,resume返回false与错误消息。

可以看到resume无论如何都不会导致程序崩溃。它是在保护模式下执行的

2. coroutine.yield()函数

使正在执行的协程挂起,注意是执行完该函数后才会使协程挂起

(1) yeild的参数会作为resume的第二个返回值

(2) 如果对该协程不是第一次执行resume,resume函数传入的参数将会作为yield的返回值

yield()和resume()的关系如下图

 

3. 协程状态

suspended:挂起状态,协程刚创建完成时或者yield之后

running       :运行状态,如果在协程的函数中调用status,传入协程自身的句柄,那么执行到这里的时候才会返回running状态

normal        :如果协程A  resume() 协程B时,则协程A处于的状态为normal。在协程B的执行过程中,协程A就一直处于normal状态。因为它这时候既不是挂起状态、也不是运行状态

dead          :结束状态,如果一个协程发生错误结束或正常运行结束。那么就处于dead状态,这时候如果调用resume()的话会直接返回false,且报错"cannot resume dead coroutine"

4. 代码示例

4. 1  协程状态及yield()与resume()的交互

-- 打印协程1和协程2的状态
function status()
    print("co1's status :"..coroutine.status(co1).." ,co2's status: "..coroutine.status(co2))
end

-- 协程1
co1 = coroutine.create(function ( a )
    print("co1 arg is :"..a)
    status()

    -- 唤醒协程2
    local stat,rere = coroutine.resume(co2,"2")
    print("111 co2 resume's return is "..rere)
    status()

    -- 再次唤醒协程2
    local stat2,rere2 = coroutine.resume(co2,"4")
    print("222 co2 resume's return is "..rere2)
    local arg = coroutine.yield("6")
end)

-- 协程2
co2 = coroutine.create(function ( a )
    print("co2 arg is :"..a)
    status()
    local rey = coroutine.yield("3")
    print("co2 yeild's return is " .. rey)
    status()
    coroutine.yield("5")
end)

--主线程执行协程co1,传入字符串“main thread arg”
stat,mainre = coroutine.resume(co1,"main thread arg")
status()
print("last return is "..mainre)
结果及笔者的注释:

co1 arg is :main thread arg                -- 开始执行协程1,第8行
co1's status :running ,co2's status: suspended        -- 协程1中,第9行,调用了status()函数
co2 arg is :2                        -- 协程1中,第12行,调用了resume(),唤醒协程2,调用到24行
co1's status :normal ,co2's status: running        -- 注意:此时协程1处于normal状态,协程2处于running状态
111 co2 resume's return is 3                -- 由于26行,协程2执行了yiled(),协程挂起,参数“3”被返回到协程1,赋值给了12行中resume()的第二个参数,在13行进行此打印
co1's status :running ,co2's status: suspended        -- 此时协程1被唤醒,处于running状态,协程2处于挂起状态
co2 yeild's return is 4                    -- 由于17行,协程2被再次唤醒,由于不是第一次调用resume(),参数“4”被赋值给上次26行的yiled()的返回值,打印出来,此时是27行的
co1's status :normal ,co2's status: running        -- 同第一次,此时协程1处于normal状态,协程2处于running状态
222 co2 resume's return is 5                -- 由于第29行执行yield完毕,参数5作为17行的resume()的返回值,在18行进行了打印,注意此时协程2仍未结束,处于挂起状态
co1's status :suspended ,co2's status: suspended    -- 由于第19行,执行了yield(),参数“6”被返回给33行的mainre,注意:此时协程1挂起,同样也未执行完
last return is 6                    -- 最终35行进行了打印,mainre的值,也就是resume()的第二个返回值其实就是yidld()的参数
4.2 下面这段代码摘取云风的,演示yield()和resume()的交互

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"))
结果及笔者的备注:

co-body    1    10        -- 协程co的第7行,此时resume()传入的参数是赋值给了函数的
foo    2            -- 在第8行里面调用了函数foo(),执行到第2行的打印
main    true    4        -- 由于函数foo()的第3行yield()执行后挂起,参数是4,作为第15行的resume()的第二个返回值,最终打印了出来,到此,第15行执行完毕
co-body    r            -- 第16行resume()再次唤醒协程co,接着上次yield()的地方继续执行,参数“r"被赋值给上次yield()的返回值,在第9行打印出来
main    true    11    -9    -- 在第10行yiled()后再次挂起协程co,并返回,此时参数a和b还是第一次resume()时的参数,1,10,所以yield()两个参数分别为11,-9,作为resum()的第二个返回值,最终被打印出来,到此,第16行执行完毕
co-body    x    y        -- 第17行resume()再次唤醒协程co,传入的参数“x”,“y”被赋值给上次的yield()函数的返回值,即赋值给第10行的r,s,在第11行被打印出来
main    true    10    end    -- 协程co在第12行返回,注意此时参数b仍然是第一次resume()时的参数2,值为10,至此协程co执行结束,变为dead状态,最终在第17行打印出来
main    false    cannot resume dead coroutine -- 第18行尝试再次resume()协程co,由于协程co已经为dead状态,所以直接返回并报错
4.3 生产者消费者

-- 生产者协程,负责产生数据(由控制台输入),然后挂起协程,把值传递给过滤器协程
produceFunc = function()
    while true do
        local value = io.read()                        -- 等待输入,即生产数据
        print("produce: ", value)
        coroutine.yield(value)                       -- 挂起本生产者协程,返回生产的值
    end
end

-- 过滤器协程,唤醒生产者协程,等待其产生数据,得到数据后,负责把数据放大100倍,然后挂起协程,把值传递给消费者函数
filteFunc = function(p)
    while true do
        local status, value = coroutine.resume(p);     -- 唤醒生产者协程,直到其返回数据
        value = value *100                            -- 把数据放大100倍
        print("filte:     ", value)
        coroutine.yield(value)                        -- 挂起本过滤器协程,返回处理后的值
    end
end

-- 消费者,只是个函数,并非协程,while一直调用,即一直唤醒过滤器协程
consumer = function(f, p)
    while true do
        local status, value = coroutine.resume(f, p);--唤醒过滤器协程,参数是生产者协程
        print("consume: ", value)                    -- 打印出得到的值,即消费
    end
end

--备注:
-- 1. 消费者驱动的设计,也就是消费者需要产品时找生产者请求,生产者完成生产后提供给消费者
-- 2. 这里做了中间的过滤器协程,即消费者函数找过滤器协程,过滤器协程找生产者协程,等待其返回数据,再原路返回,传递给消费者函数,while一直循环

-- 生产者协程
producer = coroutine.create(produceFunc)

--过滤器协程
filter = coroutine.create(filteFunc)

-- 消费者函数,传入过滤器协程和生产者协程
consumer(filter, producer)
结果:笔者输入123,99做示例

123
produce:     123
filte:         12300
consume:     12300
99
produce:     99
filte:         9900
consume:     9900
 
————————————————
版权声明:本文为CSDN博主「YZF_Kevin」的原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/yzf279533105/article/details/79982139

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页