14:协同(coroutine)

01：

coroutine.create() 创建 coroutine，返回 coroutine， 参数是一个函数，当和 resume 配合使用的时候就唤醒函数调用
coroutine.resume() 重启 coroutine，和 create 配合使用
coroutine.yield() 挂起 coroutine，将 coroutine 设置为挂起状态，这个和 resume 配合使用能有很多有用的效果
coroutine.status() 查看 coroutine 的状态
注：coroutine 的状态有三种：dead，suspended，running，具体什么时候有这样的状态请参考下面的程序
coroutine.wrap（） 创建 coroutine，返回一个函数，一旦你调用这个函数，就进入 coroutine，和 create 功能重复
coroutine.running() 返回正在跑的 coroutine，一个 coroutine 就是一个线程，当使用running的时候，就是返回一个 corouting 的线程号

02：

--定义协程方式01
co=coroutine.create(
function(x,y)
print(x+y)
end
)

--启动协程
coroutine.resume(co,1,1)
--2

cp=coroutine.wrap(
function(x,y)
print(x+y)
end
)

cp(1,40)

03:协程的暂停和重启

--定义协程
co=coroutine.create(
function(x,y)
print(x+y)
print(x+y)
--暂停协程
coroutine.yield(x*y)
print(x-y)

end
)
--启动协程
res,res1=coroutine.resume(co,1,1)
print(res,res1)
--重启协程
coroutine.resume(co)

04：返回值

--定义协程
co=coroutine.create(
function(x,y)
print(x+y)
print(x+y)
--暂停协程 返回值在yield方法里
coroutine.yield(x*y)

print(x-y)
return(x*y)
end
)
--启动协程
res,res1=coroutine.resume(co,1,1)
print(res,res1)
--重启协程
res2,res3=coroutine.resume(co)

print(res2,res3)

05：
获取协程状态

--定义协程
co=coroutine.create(
function(x,y)
print(x+y)
print(x+y)
print(coroutine.status(co))
--暂停协程 返回值在yield方法里
coroutine.yield(x*y)

print(x-y)
return(x*y)
end
)
print(coroutine.status(co))
--启动协程
res,res1=coroutine.resume(co,1,1)

print(res,res1)
--重启协程
res2,res3=coroutine.resume(co)
print(coroutine.status(co))

print(res2,res3)

--suspended
--2
--2
--running
t--rue	1
--0
--dead

2. coroutine.yield()函数

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

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

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

06.示例

-- 打印协程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()的参数

local util = require "xlua.util"

class "LuaCoroutine"
{
    __ctor__ = function(self, mono)
        self.mono = mono
    end,

    WaitForIEnumerator = function(self, enumerato, fun)
        if self.mono then
            local co = util.cs_generator(
                function()
                    coroutine.yield(enumerato)
                    if fun then
                        fun()
                    end
                end
            )
            return self.mono:StartCoroutine(co)
        end
        return nil
    end,

    Wait = function(self, time, fun)
        if self.mono then
            local co = util.cs_generator(
                function()
                    if time == 0 then
                        coroutine.yield(CS.UnityEngine.WaitForEndOfFrame())
                    else
                        coroutine.yield(CS.UnityEngine.WaitForSeconds(time))
                    end
                    if fun then
                        fun()
                    end
                end
            )
            return self.mono:StartCoroutine(co)
        end
        return nil
    end,

    Stop = function(self, co)
        if self.mono and co then
            self.mono:StopCoroutine(co)
        end
    end,

    StopAll = function(self)
        if self.mono then
            self.mono:StopAllCoroutines()
        end
    end,

    Cancel = function(self)
        self:StopAll()
        self.mono = nil
    end
}

最后

以上就是缥缈万宝路为你收集整理的14:协同(coroutine)的全部内容，希望文章能够帮你解决14:协同(coroutine)所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。