Lua 基础之协同程序

左手的ㄟ右手 2022-06-12 09:54 200阅读 0赞

# 协同程序 #

*  协同程序类似于多线程中的线程。lua 提供 *非对称的协同程序* ，即 lua 提供两个函数来控制协同程序的执行，一个用于挂起执行，另一个用于恢复执行。
 *  协同程序的函数放置在表 *coroutine* 中，创建时传入一个函数，生成一个 *thread* 类型的值
 *  协同程序的四种状态：挂起(suspended)，运行(running)、死亡(dead)，正常(normal)
 *  使用 *status* 函数来查看协程的状态，协程创建时的状态是 *挂起*
 *  使用 *resume* 函数可以唤醒协程，将其状态由 *挂起* 变为 *运行*
 *  如果协程执行一次就完了，那它的状态就会变成 *死亡*
 *  使用 *yield* 函数来挂起协程，将其状态由 *运行* 变为 *挂起*
 *  当协程 A 唤醒另一个协程 B 时，A 就处于一个特殊的状态，称为 *正常*
 *  协程的挂起操作发生在 *yield* 函数中，也就是说协程运行到 *yield* 函数时暂停，没有从 *yield* 函数返回，当下次执行 *resume* 的时候才从 *yield* 返回，然后继续执行，直到遇到下一次 *yield* 或协程运行结束

local mod = ...
    
    local m = {}
    
    _G[mod] = m
    package.loaded[mod] = m
    
    m.main = function()
        while coroutine.status(m.co) ~= [[dead]] do
            io.read()
            coroutine.resume(m.co)
        end
    end
    
    m.co = coroutine.create(
        function()
            for i = 1, 10 do
                print("co", i)
                coroutine.yield()
            end
        end
    )

## 使用 resume-yield 交换数据 ##

*  第一次唤醒协程，resume 参数传给协程主函数

coroutine.resume(m.co2, 1, 2, 3)
    coroutine.resume(m.co2, 10, 20, 30)
    
    m.co2 = coroutine.create(
        function(a, b, c)
            while true do
                print("co", a, b, c)
                coroutine.yield()
            end
        end
    )

> co 1 2 3  
> co 1 2 3

从输出结果可以看出，第一次调用 resume 时，参数的值传给了 a,b,c，第二次调用时则不会

*  yield 传入的参数值传给 resume

print(coroutine.resume(m.co2, 1, 2, 3))
    print(coroutine.resume(m.co2, 10, 20, 30))
    
    m.co2 = coroutine.create(
        function(a, b, c)
            while true do
                print("co", a, b, c)
                coroutine.yield(a + b, a + c, b + c)
            end
        end
    )

> co 1 2 3  
> true 3 4 5  
> co 1 2 3  
> true 3 4 5

*  yield 的返回值是 resume 传入的参数

print(coroutine.resume(m.co2, 1, 2, 3))
    print(coroutine.resume(m.co2, 10, 20, 30))
    
    m.co2 = coroutine.create(
        function(a, b, c)
            while true do
                print("co", coroutine.yield())
            end
        end
    )

> true  
> co 10 20 30  
> true

第一次调用 resume 时，传入的参数 1,2,3 被参数 a,b,c 接收了，然后协程在 yield 函数中挂起，第二次调用 resume，传入的 10,20,30 作为 yield 的返回值，yield 返回到协程继续执行，输出 `co 10 20 30`

*  协程运行完毕，主函数返回值传给 resume

print(coroutine.resume(m.co2, 1, 2, 3))
    print(coroutine.resume(m.co2, 10, 20, 30))
    
    m.co2 = coroutine.create(
        function(a, b, c)
            coroutine.yield()
            return a + b + c
        end
    )

> true  
> true 6

### 总结 ###

1.  resume 第一次执行，参数传给协程主函数
2.  resume 再次执行，参数作为 yield 的返回值
3.  协程挂起时 yield 的参数作为 resume 的返回值
4.  协程死亡时主函数的返回值作为 resume 的返回值

# 生产者-消费者 #

生产者-消费者是一个经典的协同程序，生产者不停地生产值，然后发送给消费者；消费者不停地接收值，然后催促生产者生产；两者都有自己的主循环，都把自己当作调用的主动方，但实际程序只能有一方是主动方，而另一方则必须由主动方来唤醒，执行一次之后挂起，下面就是一个 *消费者驱动* 的例子

-- 生产者设计成协程
    m.producer = coroutine.create(
        function()
            while true do
                local value = tonumber(io.read())
                if value == -1 then
                    break
                end
                -- 生产者生产值之后挂起
                coroutine.yield(value)
            end
        end
    )
    
    -- 消费者驱动
    m.customer = function()
        while true do
            -- 消费者唤醒生产者
            local status, value = coroutine.resume(m.producer)
            if status == false or coroutine.status(m.producer) == "dead" then
                break
            end
            io.write(value, "\n")
        end
    end

可以在生产者和消费者之前加一个过滤器。生产者是一个协程，过滤器也是一个协程；然后消费者唤醒过滤器，过滤器再唤醒生产者，生产者产生值之后就挂起自己，过滤器接收生产的值后也挂起自己，最后消费者接收生产的值后继续唤醒过滤器

-- 生产者设计成协程
    m.producer = function()
        return coroutine.create(
            function()
                while true do
                    local value = io.read()
                    if value == "-1" then
                        break
                    end
                    -- 生产者生产值之后挂起
                    coroutine.yield(value)
                end
            end
        )
    end
    
    -- 过滤器设计成协程
    m.filter = function(producer)
        return coroutine.create(
            function()
                for line = 1, math.huge do
                    -- 唤醒生产者
                    local status, value = coroutine.resume(producer)
                    -- 生产者死亡
                    if status == false or coroutine.status(producer) == "dead" then
                        break
                    end
                    x = string.format("%-5d %s", line, value)
                    -- 过滤器得到生产值之后挂起
                    coroutine.yield(x)
                end
            end
        )
    end
    
    -- 消费者驱动
    m.customer = function(filter)
        while true do
            -- 唤醒过滤器
            local status, value = coroutine.resume(filter)
            -- 过滤器死亡
            if status == false or coroutine.status(filter) == "dead" then
                break
            end
            io.write(value, "\n")
        end
    end