章志强的专栏

系统分析师+证券分析师,从事Windows/Linux/移动平台下C/C++/Lua/JavaScript/Python/JAVA等语言设计开发,专注于金融交易系统和P2P分布式网络研究与开发,以及物...

Lua —— Coroutines

Q:什么是”Coroutine”?

A:有些类似于多线程,但他们之间也有区别, 
1、从概念上来看,多线程是同一时间所有的线程同时都在运行。而一组”Coroutines”在同一时间只有一个”Coroutine”在运行。 
2、从应用场景来看,多线程一般起到分流的作用,每个线程专注做自己的事情,线程之间合作的关系较弱。而一组”Coroutines”之间合作的关系就比较强,他们都是在做同一件事情,他们分摊了这件事情中的工作。

Q:如何使用”Coroutines”?

A:

-- 创建"Coroutines"。
co = coroutine.create(function()
         print("hi")
     end)
print(type(co))    --> thread    -- "Coroutine"是个"thread"。

-- "Coroutine"有3种状态:挂起,运行,死亡。
-- 当"Coroutine"被创建之后默认是挂起状态。
print(coroutine.status(co))    --> suspended
-- 运行"Coroutine"。
coroutine.resume(co)    --> hi
-- "Coroutine"在运行完成之后变为死亡状态。
print(coroutine.status(co))    --> dead

目前看起来”Coroutine”与普通的函数调用没有太大区别,但他真正强大的地方在于coroutine.yield(),它可以让运行中的”Coroutine”挂起,

co = coroutine.create(function ()
         for i=1, 10 do
             print("co", i)
             coroutine.yield()    -- 挂起"Coroutine"。
         end
     end)
coroutine.resume(co)    --> co   1
coroutine.resume(co)    --> co   2
coroutine.resume(co)    --> co   3
...
co)    --> co   10
coroutine.resume(co)    -- prints nothing -- "for"循环结束。

以及coroutine.resume()coroutine.yield()之间可以方便的交换数据,

-- 可以通过"coroutine.resume()"向"coroutine"调用的函数传递参数。
co = coroutine.create(function(a, b)
         print("co", a, b)
     end)
coroutine.resume(co, 1, 2)    --> co  1  2

--[[ 可以通过"coroutine.yield()"向"coroutine.resume()"传递参数。
     "coroutine.yield()"传递的参数由"coroutine.resume()"的返回值呈现。]]
co = coroutine.create(function(a, b)
         for i = 1, 3 do
             print(i, a, b)
             coroutine.yield(i, a + b, a - b)
         end
     end)
print(coroutine.resume(co, 20, 10))
print(coroutine.resume(co, 50, 10))
print(coroutine.resume(co, 70, 90))
--[[ 结果。
     这里可以看到,第一次"coroutine.resume()"所传递的参数,
     将作为之后每次"coroutine.resume()"所传递的参数,
     无论之后的"coroutine.resume()"是否指定了新的参数。]]
1   20  10
true    1   30  10
2   20  10
true    2   30  10
3   20  10
true    3   30  10

--[[ 对称的,可以通过"coroutine.resume()"向"coroutine.yield()"传递参数。
     "coroutine.resume()"传递的参数由"coroutine.yield()"的返回值呈现。]]
co = coroutine.create (function(a, b)
         for i = 1, 3 do
             print(i, a, b)
             print("co", coroutine.yield())
         end
     end)
coroutine.resume(co, "first", "call", "discard")
coroutine.resume(co, "second", "call")
coroutine.resume(co, "third", "call")
coroutine.resume(co, "fourth", "call")
--[[ 结果。
     这里可以看到,
     1、从创建"coroutine"之后的第一次"coroutine.resume()"
     传递的多余参数被丢弃了。
     2、与上面的例子相同,第一次"coroutine.resume()"所传递的参数,
     将作为之后每次"coroutine.resume()"所传递的参数,
     无论之后的"coroutine.resume()"是否指定了新的参数。
     3、第一次之后的"coroutine.resume()"所传递的参数
     都会被视作传递给"coroutine.yield()"的参数。
     4、当"coroutine"被挂起时,"coroutine.yield()"并不返回,
     猜测可能是在"coroutine.yield()"内部暂停了。
     之后当"coroutine"被恢复时,"coroutine.yield()"才返回,
     猜测可能是从"coroutine.yield()"内部继续运行到"coroutine.yield()"结束返回。
     以上的现象与"coroutine"的运行流程相对应,
     在创建"coroutine"之后的第一次"coroutine.resume()"
     是从创建"coroutine"时指定的函数开始运行,
     之后的每次"coroutine.resume()"
     是从"coroutine.yield()"内部暂停的地方开始运行。]]
1   first   call
co  second  call
2   first   call
co  third   call
3   first   call
co  fourth  call

--[[ 当"coroutine"转换为死亡状态时,
     创建"coroutine"时所指定的函数所返回的值也会传递给"coroutine.resume()",
     由"coroutine.resume()"的返回值呈现。]]
co = coroutine.create(function ()
         for i = 1, 3 do
             coroutine.yield()
         end

         return 6, 7
     end)
print(coroutine.resume(co))   --> true
print(coroutine.resume(co))   --> true
print(coroutine.resume(co))   --> true
print(coroutine.resume(co))   --> true  6  7

Q:使用”Coroutines”的例子?

A:协同程序的一个典型例子是生产者和消费者问题。比如一个函数不断产生值(从一个文件中读取数据,此例中是从标准输入中读取),另一个函数不断消耗值(将数据写到另一个文件中,此例中是向标准输出写)。

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

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

function consumer ()
    while true do
        local x = receive()        -- receive from producer
        io.write(x, "\n")          -- consume new value
    end
end

producer = coroutine.create(
function ()
    while true do
        local x = io.read()     -- produce new value
        send(x)                 -- send to consumer
    end
end)

consumer()     -- 从消费者开始。
--[[ 消费者写数据需要先接收数据,调用"receive()",
     "receive()"内部会恢复"coroutines"的运行,并等待数据,
     这样主导权到了生产者手中,
     生产者读取数据并发送数据,调用"send()""send()"内部挂起"coroutines",
     此时数据通过"coroutine.yield()"传递给了"coroutine.resume()""coroutine.resume()"返回数据给"receive()",写数据。
     循环往复。]]

我们可以过滤器扩展这个例子,过滤器在生产者与消费者之间,可以对数据 
进行某些转换处理。过滤器在同一时间既是生产者,也是消费者。说的更具体一些,过滤器在同一时间,对于真正的生产者,它是消费者,对于真正的消费者,它是生产者。 
我们修改上面的例子,加入打印行号的功能,

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()
            -- 挂起producer(即自己)所在的"coroutines",返回给filter数据。
            send(x)
        end
    end)
end

function filter (prod)
    return coroutine.create(function ()
        local line = 1
        while true do
            -- 恢复producer所在的"coroutines",以让producer提供数据。
            local x = receive(prod)
            x = string.format("%5d %s", line, x)    -- 行号。
            -- 挂起filter(即自己)所在的"coroutines",返回给consumer数据。
            send(x)
            line = line + 1
        end
    end)
end

function consumer (prod)
    while true do
        -- 恢复filter所在的"coroutines",以让filter提供数据。
        local x = receive(prod)
        io.write(x, "\n")
    end
end

--[[ "producer()"创建了一组"coroutines",由filter掌控;
     "filter()"创建了一组"coroutines",由consumer掌控。]]
consumer(filter(producer()))

上面这个例子可能很自然的让你想到”UNIX”的管道。管道的方式下每一个任务在独立的进程中运行,而”coroutines”方式下每个任务运行在独立的”coroutine”中。进程之间的切换代价很高,而”coroutine”的切换的代价大致相当于函数之间的切换。

Q:如何使用”Coroutines”实现”Iterator”?

A:”Iterator”是一种典型的“生产者 - 消费者”模式,由”Iterator”产生值,由循环体消耗值。下面是一个打印数组内元素全排列的例子,我们先用递归来实现它,

-- 算法很简单,就是依次将数组中每一个元素放到数组的最后,然后计算余下元素组成的数组的全排列。
function permgen (a, n)
    if n == 0 then
        printResult(a)
    else
        for i=1,n do
            -- put i-th element as the last one
            a[n], a[i] = a[i], a[n]

            -- generate all permutations of the other elements
            permgen(a, n - 1)

            -- restore i-th element
            a[n], a[i] = a[i], a[n]
        end
    end
end

function printResult (a)
    for i,v in ipairs(a) do
        io.write(v, " ")
    end
    io.write("\n")
end

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

接下来,将其转换为”Coroutines”的实现方式就很简单了,

function permgen (a, n)
    if n == 0 then
        -- 一旦得到排列结果,"coroutine"挂起,返回结果给"coroutine.resume()"。
        coroutine.yield(a)
    else
        for i=1,n do

            -- put i-th element as the last one
            a[n], a[i] = a[i], a[n]

            -- generate all permutations of the other elements
            permgen(a, n - 1)

            -- restore i-th element
            a[n], a[i] = a[i], a[n]

        end
    end
end

-- 内部创建"coroutine"以及返回"iterator function"。
function perm (a)
    local n = #a    -- 获得数组的大小。
    -- "coroutine"负责以递归的方式产生排列结果。
    local co = coroutine.create(function () permgen(a, n) end)
    -- "iterator function"负责恢复"coroutine"以从"coroutine.yield"得到排列结果。
    return function ()
        local code, res = coroutine.resume(co)
        return res
    end
end

function printResult (a)
    for i,v in ipairs(a) do
        io.write(v, " ")
    end
    io.write("\n")
end

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

perm()使用了Lua中一种常用的模式:将恢复”coroutine”的操作封装在一个函数里。这种模式在Lua中经常被使用,所以Lua提供coroutine.wrap()来实现这种操作。与coroutine.create()相比,coroutine.create()返回”coroutine”本身,而coroutine.wrap()在内部调用coroutine.resume()后,等待coroutine.resume()返回并返回其结果。当coroutine.resume()成功恢复了”coroutine”时,coroutine.wrap()返回coroutine.resume()除了第一个返回值(即”errcode”,true or false)外的其他返回值。而当coroutine.resume()恢复”coroutine”失败时,coroutine.wrap()直接报错。 
所以,我们可以将原先perm()的实现更改为使用coroutine.wrap()

function perm (a)
  local n = #a
  return coroutine.wrap(function () permgen(a, n) end)
end

Q:如何使用”coroutines”实现抢占式线程?

A:”coroutines”是非抢占式的协作线程,这意味着在明确的指明要他停止(通过调用coroutine.yield())之前,他不能被其他线程打断,这种机制在某些需要高实时性的场合是不能被接收的。 
抢占式线程的“抢占”其原理就在于CPU为每个线程分配一个时间片,当时间片耗尽而线程的工作还没有完成时,CPU就强制将该线程暂停同时让另一个线程开始工作。 
使用”coroutines”也可以实现抢占式线程,其原理就在于由我们自己为每一对”coroutine”分配时间片。以下的例子简单的实现了抢占式线程,每个线程的工作都是计算某个整数区间内所有整数之和,

threads = {}    -- 调度表。所有工作中的线程都会存入此表。
time = os.time()    -- 每个线程开始工作时的时间。当线程被挂起时会更新这个时间。
limit_time = 1    -- 时间片。每个线程给1s的工作时间。

-- 计算某个整数区间内所有整数之和。
function cal(from, to)
    local sum = 0;
    for i = from, to do
        sum = sum + i
        -- 时间片耗尽,而工作还没有完成。
        if (os.time() - time) >= limit_time then
            -- 打印计算进度。
            print(string.format("Worker %d calculating, %f%%.", worker, (i / to * 100)))
            time = os.time()    -- 当进程被挂起时更新时间,下一个进程将以此作为开始工作时的时间。
            coroutine.yield()    -- 休息。
        end
    end
    -- 工作完成,打印计算结果。
    print(string.format("Worker %d finished, %d.", worker, sum))
end

-- 分配任务。
function job (from, to)
    -- 创建"coroutine"。
    local co = coroutine.create(function ()
        cal(from, to)
    end)
    table.insert(threads, co)    -- 将线程加入调度表。
end

-- 4个线程,分别计算不同整数区间内所有整数之和。
job(1, 100000000)
job(10, 50000000)
job(5000, 6000000)
job(10000, 70000000)

-- 分发器。调度所有线程的运行。
while true do
    local n = #threads
    if n == 0 then break end   -- 没有线程需要工作了。
    for i = 1, n do
        worker = i    -- 表示哪个线程在工作。
        local status = coroutine.resume(threads[i])    -- 恢复"coroutine"工作。
        if not status then    -- 线程是否完成了他的工作?"coroutine"完成任务时,status是"false"。
            table.remove(threads, i)    -- 将线程从调度表中删除。
            break
        end
    end
end

Worker 1 calculating, 0.482016%. 
Worker 2 calculating, 10.191070%. 
Worker 3 calculating, 85.029767%. 
Worker 4 calculating, 7.273926%. 
Worker 1 calculating, 5.534152%. 
Worker 2 calculating, 20.370044%. 
Worker 3 finished, 17999990502500. <– 3号线程完成工作。 
Worker 4 calculating, 13.201869%. 
Worker 1 calculating, 10.590240%. 
Worker 2 calculating, 30.563072%. 
Worker 1 calculating, 15.656026%. 
Worker 2 calculating, 40.731870%. 
Worker 3 calculating, 20.430621%. <– 原先的4号线程变为3号线程。 
Worker 1 calculating, 20.689852%. 
Worker 2 calculating, 50.912444%. 
Worker 3 calculating, 27.682421%. 
Worker 1 calculating, 25.750115%. 
Worker 2 calculating, 61.074508%. 

实现的思路也很清晰。一个调度器拥有一张调度表,其中存储了需要工作的线程。调度器为每个线程分配一个时间片,当发现线程的时间片耗尽,则挂起线程同时让调度表中的下一个开始工作。当发现线程的工作完成时,则从调度表中移除该线程。总的来说,通过调度器与时间片,使用”coroutines”实现了简单的抢占式线程。

附加:

1、coroutine.resume()会返回一个”bool”值,表示是否成功的恢复了挂起的”Coroutine”,

-- 处于挂起状态的"Coroutine"可以恢复。
print(coroutine.status(xxx))    --> suspended
print(coroutine.resume(xxx))    --> true
-- 已处于死亡状态的"Coroutine"无法恢复。
print(coroutine.status(xxx))    --> dead
print(coroutine.resume(xxx))    --> false   cannot resume dead coroutine

2、在生产者和消费者问题的第一个例子中, 
开始时调用消费者,当消费者需要值时他唤起生产者生产值,生产者生产值后停止直到消费者再次请求。我们称这种设计为消费者驱动的设计。 
3、”coroutines”是一种协作的多线程。每一个”coroutine”相当于一个线程。”yield-resume”的组合可以在线程之间互相转换。然而,区别于真正的多线程,”coroutines”是非抢占的。当一个”coroutine”在运行的时候,他不能被其他的线程所打断,除非明确的指明要他停止(通过调用coroutine.yield())。编写非抢占式的多线程也比编写抢占式的多线程容易的多,因为你不用担心线程之间的同步问题所造成的bugs,你只需要确定当”coroutine”被挂起时他不是处在临界区。

阅读更多
想对作者说点什么? 我来说一句

Ulua v1.18

2015年07月31日 4.34MB 下载

unity官方原版最新uLua 1.03(原价40$)

2016年01月12日 2.65MB 下载

没有更多推荐了,返回首页

不良信息举报

Lua —— Coroutines

最多只允许输入30个字

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭