14:协同(coroutine)

1
2
3
4
5
6
7
8
9
10
11
--定义协程方式01
co=coroutine.create(
function(x,y)
print(x+y)
end
)

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

1
2
3
4
5
6
7
8
9
10

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

cp(1,40)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
--定义协程
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)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
--定义协程
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)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
--定义协程
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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
-- 打印协程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()的参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
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
}