13.协同程序

热更新 > Lua > Lua语法知识 语法知识 热更新 Lua
发布时间 :
字数:3.5k 阅读 : 评论:
  1. 13.协同程序
    1. 13.1 知识点
      1. 协程的创建
        1. 线程型 coroutine.create(函数变量)
        2. 函数型 coroutine.wrap(函数变量)
      2. 协程的执行
        1. 线程型 coroutine.resume(协程变量)
        2. 函数型 协程变量()
      3. 协程的挂起和分布执行
        1. 挂起线程型协程 coroutine.yield(返回值1，..返回值n)和coroutine.resume(协程变量)
        2. 挂起函数型协程 coroutine.yield(返回值1，..返回值n)和协程变量()
      4. 协程的状态 coroutine.status(协程变量)
      5. 函数中得到协程的线程号 coroutine.running()
    2. 13.2 知识点代码

13.协同程序

13.1 知识点

协程的创建

  • 创建协程有两种方法 create 和 wrap 分别创建线程型和函数型的协程变量。

线程型 coroutine.create(函数变量)

myFunction1 = function()
    print("我是myFunction1")
end
--coroutine.create(函数变量) 会返回线程thread类型的变量 较常用
myCoroutine1 = coroutine.create(myFunction1)
print(myCoroutine1)       --thread: 00B5EA90
print(type(myCoroutine1)) --thread

函数型 coroutine.wrap(函数变量)

--coroutine.wrap(函数变量) 会返回函数function类型的变量 不太常用
myCoroutine2 = coroutine.wrap(function()
    print("我是myFunction2")
end)                      --可以传入时声明函数
print(myCoroutine2)       --function: 00DBE058
print(type(myCoroutine2)) --function

协程的执行

  • 执行协程有两种方法 resume 和括号执行，分别对应 create 线程型和 wrap 函数型创建的协程变量。

线程型 coroutine.resume(协程变量)

-- coroutine.resume(协程变量) 协程变量要是协程型
coroutine.resume(myCoroutine1) -- 我是myFunction1

函数型 协程变量()

-- 协程变量() 协程变量要是函数型
myCoroutine2() -- 我是myFunction2

协程的挂起和分布执行

  • 挂起协程是在函数中使用 coroutine.yield 方法并返回值，create 线程型和 wrap 函数型创建的协程变量分别使用 resume 和括号分步执行协程。

挂起线程型协程 coroutine.yield(返回值1，..返回值n)和coroutine.resume(协程变量)

--在函数中使用 coroutine.yield(返回值1，返回值2,...返回值n)
myFunction3 = function()
    local i = 1
    while true do
        for j = 1, 3 do
            print("myFunction3中打印值" .. " i:" .. i .. " j:" .. j)
            coroutine.yield(i, j)
        end
        i = i + 1
    end
end
--使用 coroutine.create(函数变量) 创建的协程
--使用 coroutine.resume(协程变量) 逐步执行函数并得到当前返回值
--默认第一个返回值是协程是否启动成功 之后的返回值依次是函数中coroutine.yield()里的返回值
myCoroutine3 = coroutine.create(myFunction3) --线程型协程
isCoroutineSuccessLaunch, tempI, tempJ = coroutine.resume(myCoroutine3)
print("线程型协程的返回值：", isCoroutineSuccessLaunch, tempI, tempJ)
isCoroutineSuccessLaunch, tempI, tempJ = coroutine.resume(myCoroutine3)
print("线程型协程的返回值：", isCoroutineSuccessLaunch, tempI, tempJ)
isCoroutineSuccessLaunch, tempI, tempJ = coroutine.resume(myCoroutine3)
print("线程型协程的返回值：", isCoroutineSuccessLaunch, tempI, tempJ)
isCoroutineSuccessLaunch, tempI, tempJ = coroutine.resume(myCoroutine3)
print("线程型协程的返回值：", isCoroutineSuccessLaunch, tempI, tempJ)
isCoroutineSuccessLaunch, tempI, tempJ = coroutine.resume(myCoroutine3)
print("线程型协程的返回值：", isCoroutineSuccessLaunch, tempI, tempJ)
isCoroutineSuccessLaunch, tempI, tempJ = coroutine.resume(myCoroutine3)
print("线程型协程的返回值：", isCoroutineSuccessLaunch, tempI, tempJ)
isCoroutineSuccessLaunch, tempI, tempJ = coroutine.resume(myCoroutine3)
print("线程型协程的返回值：", isCoroutineSuccessLaunch, tempI, tempJ)
isCoroutineSuccessLaunch, tempI, tempJ = coroutine.resume(myCoroutine3)
print("线程型协程的返回值：", isCoroutineSuccessLaunch, tempI, tempJ)
isCoroutineSuccessLaunch, tempI, tempJ = coroutine.resume(myCoroutine3)
print("线程型协程的返回值：", isCoroutineSuccessLaunch, tempI, tempJ)
isCoroutineSuccessLaunch, tempI, tempJ = coroutine.resume(myCoroutine3)
print("线程型协程的返回值：", isCoroutineSuccessLaunch, tempI, tempJ)
isCoroutineSuccessLaunch, tempI, tempJ = coroutine.resume(myCoroutine3)
print("线程型协程的返回值：", isCoroutineSuccessLaunch, tempI, tempJ)
-- myFunction3中打印值 i:1 j:1
-- 线程型协程的返回值：	true	1	1
-- myFunction3中打印值 i:1 j:2
-- 线程型协程的返回值：	true	1	2
-- myFunction3中打印值 i:1 j:3
-- 线程型协程的返回值：	true	1	3
-- myFunction3中打印值 i:2 j:1
-- 线程型协程的返回值：	true	2	1
-- myFunction3中打印值 i:2 j:2
-- 线程型协程的返回值：	true	2	2
-- myFunction3中打印值 i:2 j:3
-- 线程型协程的返回值：	true	2	3
-- myFunction3中打印值 i:3 j:1
-- 线程型协程的返回值：	true	3	1
-- myFunction3中打印值 i:3 j:2
-- 线程型协程的返回值：	true	3	2
-- myFunction3中打印值 i:3 j:3
-- 线程型协程的返回值：	true	3	3
-- myFunction3中打印值 i:4 j:1
-- 线程型协程的返回值：	true	4	1
-- myFunction3中打印值 i:4 j:2
-- 线程型协程的返回值：	true	4	2

挂起函数型协程 coroutine.yield(返回值1，..返回值n)和协程变量()

--在函数中使用 coroutine.yield(返回值1，返回值2,...返回值n)
myFunction4 = function()
    local i = 1
    while true do
        for j = 1, 3 do
            print("myFunction4中打印值" .. " i:" .. i .. " j:" .. j)
            coroutine.yield(i, j)
        end
        i = i + 1
    end
end
--使用 coroutine.wrap(函数变量) 创建的协程
--使用 协程变量() 逐步执行函数并得到当前返回值
-- 返回值依次是函数中coroutine.yield()里的返回值 没有第一个默认的协程是否启动成功
myCoroutine4 = coroutine.wrap(myFunction4) --函数型协程
print("函数型协程的返回值：", myCoroutine4())
print("函数型协程的返回值：", myCoroutine4())
print("函数型协程的返回值：", myCoroutine4())
print("函数型协程的返回值：", myCoroutine4())
print("函数型协程的返回值：", myCoroutine4())
print("函数型协程的返回值：", myCoroutine4())
print("函数型协程的返回值：", myCoroutine4())
print("函数型协程的返回值：", myCoroutine4())
print("函数型协程的返回值：", myCoroutine4())
print("函数型协程的返回值：", myCoroutine4())
print("函数型协程的返回值：", myCoroutine4())
-- myFunction4中打印值 i:1 j:1
-- 函数型协程的返回值：	1	1
-- myFunction4中打印值 i:1 j:2
-- 函数型协程的返回值：	1	2
-- myFunction4中打印值 i:1 j:3
-- 函数型协程的返回值：	1	3
-- myFunction4中打印值 i:2 j:1
-- 函数型协程的返回值：	2	1
-- myFunction4中打印值 i:2 j:2
-- 函数型协程的返回值：	2	2
-- myFunction4中打印值 i:2 j:3
-- 函数型协程的返回值：	2	3
-- myFunction4中打印值 i:3 j:1
-- 函数型协程的返回值：	3	1
-- myFunction4中打印值 i:3 j:2
-- 函数型协程的返回值：	3	2
-- myFunction4中打印值 i:3 j:3
-- 函数型协程的返回值：	3	3
-- myFunction4中打印值 i:4 j:1
-- 函数型协程的返回值：	4	1
-- myFunction4中打印值 i:4 j:2
-- 函数型协程的返回值：	4	2

协程的状态 coroutine.status(协程变量)

  • coroutine.status(协程变量) 得到当前协程的状态，并且协程变量一定要是线程型的。
  • 协程的状态有：
    • dead：结束
    • suspended：暂停
    • running：进行中
print(coroutine.status(myCoroutine1)) --dead 因为myCoroutine1已经执行完毕 myCoroutine1中的函数myFunction1没有coroutine.yield方法

-- print(coroutine.status(myCoroutine2))--报错 因为是函数型协程

print(coroutine.status(myCoroutine3)) --suspended myCoroutine3中的函数myFunction3有coroutine.yield方法

-- print(coroutine.status(myCoroutine4))--报错 因为是函数型协程

myFunction5 = function()
    print("我是myFunction5")
    --协程的挂起函数
    print(coroutine.status(myCoroutine5)) --running 因为当前协程myCoroutine5正在运行中
    -- print(coroutine.running())
    coroutine.yield()
end
myCoroutine5 = coroutine.create(myFunction5)               --线程型协程
isCoroutineSuccessLaunchJ = coroutine.resume(myCoroutine5) --在函数中打印running

函数中得到协程的线程号 coroutine.running()

  • 在协程装载的函数中使用 coroutine.running() 得到当前正在运行此函数的协程的线程号
print(coroutine.running()) --nil 不在函数内

myFunction6 = function()
    while true do
        print("我是myFunction6")
        print(coroutine.running())
        coroutine.yield()
    end
end

myCoroutine61 = coroutine.create(myFunction6)               --线程型协程
isCoroutineSuccessLaunchJ = coroutine.resume(myCoroutine61) --thread: 00DFB558
isCoroutineSuccessLaunchJ = coroutine.resume(myCoroutine61) --thread: 00DFB558
isCoroutineSuccessLaunchJ = coroutine.resume(myCoroutine61) --thread: 00DFB558
--resume执行的都是同一个协程 所以函数执行的线程号一样

myCoroutine62 = coroutine.wrap(myFunction6)                 --函数型协程
myCoroutine62()                                             --thread: 00C04370
myCoroutine62()                                             --thread: 00C04370
myCoroutine62()                                             --thread: 00C04370
--虽然括号执行的协程和resume执行的函数相同 但是因为是两个协程 所以线程号不一样

13.2 知识点代码

print("**********协同程序************")


print("**********知识点一 协程的创建************")
-- 创建协程有两种方法 create和wrap 分别创建线程型和函数型的协程变量

--线程型
myFunction1 = function()
    print("我是myFunction1")
end
--coroutine.create(函数变量) 会返回线程thread类型的变量 较常用
myCoroutine1 = coroutine.create(myFunction1)
print(myCoroutine1)       --thread: 00B5EA90
print(type(myCoroutine1)) --thread

--函数型
--coroutine.wrap(函数变量) 会返回函数function类型的变量 不太常用
myCoroutine2 = coroutine.wrap(function()
    print("我是myFunction2")
end)                      --可以传入时声明函数
print(myCoroutine2)       --function: 00DBE058
print(type(myCoroutine2)) --function


print("**********知识点二 协程的执行************")
-- 执行协程有两种方法 resume和括号执行 分别对应create线程型和wrap函数型创建的协程变量

--coroutine.resume(协程变量) 协程变量要是协程型
coroutine.resume(myCoroutine1) --我是myFunction1

--协程变量() 协程变量要是函数型
myCoroutine2() --我是myFunction2


print("**********知识点三 协程的挂起************")
-- 挂起协程是在函数中使用coroutine.yield方法并返回值create线程型和wrap函数型创建的协程变量分别使用resume和括号分步执行协程

--挂起线程型协程
--在函数中使用 coroutine.yield(返回值1，返回值2,...返回值n)
myFunction3 = function()
    local i = 1
    while true do
        for j = 1, 3 do
            print("myFunction3中打印值" .. " i:" .. i .. " j:" .. j)
            coroutine.yield(i, j)
        end
        i = i + 1
    end
end
--使用 coroutine.create(函数变量) 创建的协程
--使用 coroutine.resume(协程变量) 逐步执行函数并得到当前返回值
--默认第一个返回值是协程是否启动成功 之后的返回值依次是函数中coroutine.yield()里的返回值
myCoroutine3 = coroutine.create(myFunction3) --线程型协程
isCoroutineSuccessLaunch, tempI, tempJ = coroutine.resume(myCoroutine3)
print("线程型协程的返回值：", isCoroutineSuccessLaunch, tempI, tempJ)
isCoroutineSuccessLaunch, tempI, tempJ = coroutine.resume(myCoroutine3)
print("线程型协程的返回值：", isCoroutineSuccessLaunch, tempI, tempJ)
isCoroutineSuccessLaunch, tempI, tempJ = coroutine.resume(myCoroutine3)
print("线程型协程的返回值：", isCoroutineSuccessLaunch, tempI, tempJ)
isCoroutineSuccessLaunch, tempI, tempJ = coroutine.resume(myCoroutine3)
print("线程型协程的返回值：", isCoroutineSuccessLaunch, tempI, tempJ)
isCoroutineSuccessLaunch, tempI, tempJ = coroutine.resume(myCoroutine3)
print("线程型协程的返回值：", isCoroutineSuccessLaunch, tempI, tempJ)
isCoroutineSuccessLaunch, tempI, tempJ = coroutine.resume(myCoroutine3)
print("线程型协程的返回值：", isCoroutineSuccessLaunch, tempI, tempJ)
isCoroutineSuccessLaunch, tempI, tempJ = coroutine.resume(myCoroutine3)
print("线程型协程的返回值：", isCoroutineSuccessLaunch, tempI, tempJ)
isCoroutineSuccessLaunch, tempI, tempJ = coroutine.resume(myCoroutine3)
print("线程型协程的返回值：", isCoroutineSuccessLaunch, tempI, tempJ)
isCoroutineSuccessLaunch, tempI, tempJ = coroutine.resume(myCoroutine3)
print("线程型协程的返回值：", isCoroutineSuccessLaunch, tempI, tempJ)
isCoroutineSuccessLaunch, tempI, tempJ = coroutine.resume(myCoroutine3)
print("线程型协程的返回值：", isCoroutineSuccessLaunch, tempI, tempJ)
isCoroutineSuccessLaunch, tempI, tempJ = coroutine.resume(myCoroutine3)
print("线程型协程的返回值：", isCoroutineSuccessLaunch, tempI, tempJ)
-- myFunction3中打印值 i:1 j:1
-- 线程型协程的返回值：	true	1	1
-- myFunction3中打印值 i:1 j:2
-- 线程型协程的返回值：	true	1	2
-- myFunction3中打印值 i:1 j:3
-- 线程型协程的返回值：	true	1	3
-- myFunction3中打印值 i:2 j:1
-- 线程型协程的返回值：	true	2	1
-- myFunction3中打印值 i:2 j:2
-- 线程型协程的返回值：	true	2	2
-- myFunction3中打印值 i:2 j:3
-- 线程型协程的返回值：	true	2	3
-- myFunction3中打印值 i:3 j:1
-- 线程型协程的返回值：	true	3	1
-- myFunction3中打印值 i:3 j:2
-- 线程型协程的返回值：	true	3	2
-- myFunction3中打印值 i:3 j:3
-- 线程型协程的返回值：	true	3	3
-- myFunction3中打印值 i:4 j:1
-- 线程型协程的返回值：	true	4	1
-- myFunction3中打印值 i:4 j:2
-- 线程型协程的返回值：	true	4	2

--挂起函数型协程
--在函数中使用 coroutine.yield(返回值1，返回值2,...返回值n)
myFunction4 = function()
    local i = 1
    while true do
        for j = 1, 3 do
            print("myFunction4中打印值" .. " i:" .. i .. " j:" .. j)
            coroutine.yield(i, j)
        end
        i = i + 1
    end
end
--使用 coroutine.wrap(函数变量) 创建的协程
--使用 协程变量() 逐步执行函数并得到当前返回值
-- 返回值依次是函数中coroutine.yield()里的返回值 没有第一个默认的协程是否启动成功
myCoroutine4 = coroutine.wrap(myFunction4) --函数型协程
print("函数型协程的返回值：", myCoroutine4())
print("函数型协程的返回值：", myCoroutine4())
print("函数型协程的返回值：", myCoroutine4())
print("函数型协程的返回值：", myCoroutine4())
print("函数型协程的返回值：", myCoroutine4())
print("函数型协程的返回值：", myCoroutine4())
print("函数型协程的返回值：", myCoroutine4())
print("函数型协程的返回值：", myCoroutine4())
print("函数型协程的返回值：", myCoroutine4())
print("函数型协程的返回值：", myCoroutine4())
print("函数型协程的返回值：", myCoroutine4())
-- myFunction4中打印值 i:1 j:1
-- 函数型协程的返回值：	1	1
-- myFunction4中打印值 i:1 j:2
-- 函数型协程的返回值：	1	2
-- myFunction4中打印值 i:1 j:3
-- 函数型协程的返回值：	1	3
-- myFunction4中打印值 i:2 j:1
-- 函数型协程的返回值：	2	1
-- myFunction4中打印值 i:2 j:2
-- 函数型协程的返回值：	2	2
-- myFunction4中打印值 i:2 j:3
-- 函数型协程的返回值：	2	3
-- myFunction4中打印值 i:3 j:1
-- 函数型协程的返回值：	3	1
-- myFunction4中打印值 i:3 j:2
-- 函数型协程的返回值：	3	2
-- myFunction4中打印值 i:3 j:3
-- 函数型协程的返回值：	3	3
-- myFunction4中打印值 i:4 j:1
-- 函数型协程的返回值：	4	1
-- myFunction4中打印值 i:4 j:2
-- 函数型协程的返回值：	4	2


print("**********知识点四 协程的状态************")

--coroutine.status(协程变量) 得到当前协程的状态 并且协程变量一定要是线程型的
--协程的状态有：
--dead 结束
--suspended 暂停
--running 进行中
print(coroutine.status(myCoroutine1)) --dead 因为myCoroutine1已经执行完毕 myCoroutine1中的函数myFunction1没有coroutine.yield方法
-- print(coroutine.status(myCoroutine2))--报错
print(coroutine.status(myCoroutine3)) --suspended myCoroutine3中的函数myFunction3有coroutine.yield方法
-- print(coroutine.status(myCoroutine4))--报错
myFunction5 = function()
    print("我是myFunction5")
    --协程的挂起函数
    print(coroutine.status(myCoroutine5)) --running 因为当前协程myCoroutine5正在运行中
    -- print(coroutine.running())
    coroutine.yield()
end
myCoroutine5 = coroutine.create(myFunction5)               --线程型协程
isCoroutineSuccessLaunchJ = coroutine.resume(myCoroutine5) --在函数中打印running


--在协程装载的函数中使用coroutine.running() 得到当前正在运行此函数的协程的线程号
print(coroutine.running()) --nil 不在函数内
myFunction6 = function()
    while true do
        print("我是myFunction6")
        print(coroutine.running())
        coroutine.yield()
    end
end
myCoroutine61 = coroutine.create(myFunction6)               --线程型协程
isCoroutineSuccessLaunchJ = coroutine.resume(myCoroutine61) --thread: 00DFB558
isCoroutineSuccessLaunchJ = coroutine.resume(myCoroutine61) --thread: 00DFB558
isCoroutineSuccessLaunchJ = coroutine.resume(myCoroutine61) --thread: 00DFB558
--resume执行的都是同一个协程 所以函数执行的线程号一样
myCoroutine62 = coroutine.wrap(myFunction6)                 --函数型协程
myCoroutine62()                                             --thread: 00C04370
myCoroutine62()                                             --thread: 00C04370
myCoroutine62()                                             --thread: 00C04370
--虽然括号执行的协程和resume执行的函数相同 但是因为是两个协程 所以线程号不一样
转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 785293209@qq.com

赏

©2016-2024 Tao

Built with Hexo and 3-hexo theme

×

喜欢就点赞,疼爱就打赏