【Lua学习笔记】Lua进阶——协程

已于 2023-08-01 10:51:37 修改
阅读量2.7k 收藏 7
点赞数 2
分类专栏： Lua学习笔记 文章标签： lua 学习 笔记
于 2023-07-27 17:37:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/milu_ELK/article/details/131953862
版权

在这里插入图片描述

文章目录

协程

协程是一种并发操作，相比于线程，线程在执行时往往是并行的，并且线程在创建销毁执行时极其消耗资源，并且过长的执行时间会造成主进程阻塞。而协程可以以并发时轮值时间片来执行，优点是不会阻塞，消耗资源少，可以手动控制。至于协程和线程的区别，什么是并发并行，请自行查阅或者学习操作系统理论知识。

协程的定义和调度

在Unity中，由于游戏是单线程的（这是为了其他线程不阻塞进程），因此我们常常需要使用协程。在Lua中也支持协程，例如下列代码：

Corou1 =coroutine.create(function ()
    print("我是协程1")
end)
print(Corou1)
Corou2 = coroutine.wrap(function ()
    print("我是协程2")
end)
print(Corou2)
coroutine.resume(Corou1) --开始或继续协程
Corou2()   	--运行函数
输出：
thread: 00CAEC00
function: 00CA0578
我是协程1
我是协程2

我们可以用两种不同的方法创建协程，不过返回值一个是协程（虽然thread是线程），一个是函数。所以对这两个协程的运行方式也不同。如何理解这两种方式？我想用C#的例子：

void StartCorou()  --function类型
{
    StartCoroutine(Coroutine());  --thread类型直接执行
}

IEnumerator Coroutine()
{
}

thread类型定义的就是协程本身，因此我们可以用lua提供的协程table中的方法来调用，而function类型更像是定义了一个启动函数，通过调用这个函数来执行。

在Lua中的协程有一个优点：我们可以手动执行

Corou1 =coroutine.create(function ()
    local i = 1
    while true do
        print(i)
        i = i + 1
        coroutine.yield(i)  --yield也可以返回
    end
end)

coroutine.resume(Corou1)
a,b = coroutine.resume(Corou1)
print(a,b)
coroutine.resume(Corou1)

输出:
1
2
true	3
3 

通过注释我们可以发现,resume第一个返回固定为成功判断，然后返回yield提供的变长参数
function coroutine.resume(co: thread, val1?: any, ...any)
  -> success: boolean
  2. ...any

可以看到，对于进入了yield的协程，需要我们手动执行resume才能继续执行。而非自动地轮换时间片。这样有利有弊，但我认为在调度上更加灵活了。

wrap

使用wrap的话：

function f1()
    local i = 1
    while true do
        print(i)
        i = i + 1
        coroutine.yield(i) 
    end
end
b = coroutine.wrap(f1)
print("返回值"..b())
print("返回值"..b())
print("返回值"..b())

输出：
1
返回值2
2
返回值3
3
返回值4

function coroutine.wrap(f: fun(...any):...unknown)
  -> fun(...any):...unknown

使用wrap则我们发现，wrap并不返回成功判断，而是直接返回yield给出的变长参数，这是由于其内定义的函数就只接收变长参数。

根据菜鸟教程的描述，使用wrap将创建一个协程包装器，并将协同程序函数转换为一个可直接调用的函数对象

-- 使用 coroutine.wrap 创建了一个协同程序包装器，将协同程序函数转换为一个可直接调用的函数对象
co = coroutine.wrap(
    function(i)
        print(i);
    end
)
 
co(1) --输出1

Status

Lua中的协程总共有四种状态：

function coroutine.status(co: thread)
  -> "dead"|"normal"|"running"|"suspended"
以字符串形式返回协程 co 的状态。

return #1:
    | "running"  正在运行。
    | "suspended"  挂起或是还没有开始运行。
    | "normal"  是活动的，但并不在运行。
    | "dead"  运行完主体函数或因错误停止。

让我们从下面的例子看看协程什么时候会进入这些状态：

C2 =  coroutine.create(function ()
    print("协程2执行")
    print("此时协程1:"..coroutine.status(Corou1))
    coroutine.yield()
end)
Corou1 =coroutine.create(function ()
    local i = 1
    while i<3 do
        print(i)
        i = i + 1
        if i==2 then
            coroutine.resume(C2)
        end
        print(coroutine.status(Corou1))
        coroutine.yield() 
    end
end)
print(coroutine.status(Corou1))
print("######")
coroutine.resume(Corou1)
print(coroutine.status(Corou1))
print("######")
coroutine.resume(Corou1)
print(coroutine.status(Corou1))
print("######")
coroutine.resume(Corou1)
print(coroutine.status(Corou1))
print("######")

输出：
suspended
######
1
协程2执行
此时协程1:normal
running
suspended
######
2
running
suspended
######
dead
######

从上述例子中看到，当协程未启动以及暂停中等待下一次resume时，其状态是suspended。而当协程正在执行时状态是running，当协程1执行切换到协程2时，协程1的状态是normal。最后当协程1退出时其状态是dead。

Running

running函数可以得到当前正在运行的协程（的地址）。

function coroutine.running()
  -> running: thread
  2. ismain: boolean
返回当前正在运行的协程加一个布尔量。 如果当前运行的协程是主线程，其为真。
（我试了一下没接收到这个bool，不知道什么情况）

用例：

Corou1 =coroutine.create(function ()
    local i = 1
    while i<3 do
        print(i)
        i = i + 1
        print("协程1状态:"..coroutine.status(Corou1))
        print(coroutine.running())
        coroutine.yield() 
    end
end)
coroutine.resume(Corou1)

输出：
1
协程1状态:running
thread: 00A7E1F8  <-- 协程1的地址

先抛出一个问题：如果在上述的同样代码中，执行协程2时print这个running函数，请问可以得到什么？考虑到协程1在协程2运行时是normal状态，当前运行（running）的协程应当是协程2

C2 =  coroutine.create(function ()
    print("协程2执行")
    print(coroutine.running())
    print("此时协程1:" .. coroutine.status(Corou1))
    print("协程2执行结束")
    coroutine.yield()
end)
Corou1 =coroutine.create(function ()
    local i = 1
    while i<3 do
        print(i)
        i = i + 1
        if i==2 then
            coroutine.resume(C2)
        end
        print("协程1状态:"..coroutine.status(Corou1))
        print(coroutine.running())
        coroutine.yield() 
    end
end)
coroutine.resume(Corou1)
coroutine.resume(Corou1)

输出：
1
协程2执行
thread: 00C4CFE8
此时协程1:normal
协程2执行结束
协程1状态:running
thread: 00C4D408
2
协程1状态:running
thread: 00C4D408

补充

在协程第一次被执行之后，当第二次执行该协程时不需要输入所需的参数，例如下面的例子

Corou1 =coroutine.create(function (a,b)
    coroutine.yield(a + b, a - b)
    return a*b,a/b
end)
r1, r2, r3 = coroutine.resume(Corou1,20,10)
print(r1, r2, r3)
r1, r2, r3 = coroutine.resume(Corou1)
print(r1, r2, r3)
r1, r2, r3 = coroutine.resume(Corou1,20,10)
print(r1, r2, r3)
输出：
true	30	10 --执行yield
true	200	2.0 --执行return
false	cannot resume dead coroutine	nil

此外从上例也可以看出，执行协程也可以以return作为函数最后的返回值。而且一个已经dead的协程是不会被resume执行的。如果还需要调用这个已经死掉的协程，请重新创建一个，否则报错。

协程与主程的数据交互——return…yield

综合以上知识，我们看看菜鸟教程里的这个例子：

function foo (a)
    print("foo 函数输出", a)
    return coroutine.yield(2 * a) -- 返回  2*a 的值
end
 
co = coroutine.create(function (a , b)
    print("第一次协同程序执行输出", a, b) -- co-body 1 10
    local r = foo(a + 1)
    return "协程结束"
end)
       
print(coroutine.resume(co, 1, 10)) -- true, 4
print(coroutine.resume(co)) -- true, 协程结束

输出：
第一次协同程序执行输出	1	10
foo 函数输出	2
true	4
true	协程结束

在上例中，协程co的语句中并无yield返回，而是将其放在foo函数之中，让函数执行完毕时return yield。所以这个协程在r=foo(a+1)执行完毕后就suspend了。那么究竟执行顺序是如何呢？

function foo (a)
    print("foo 函数输出", a)
    return coroutine.yield(2 * a) -- 返回  2*a 的值
end
 
co = coroutine.create(function (a , b)
    print("第一次协同程序执行输出", a, b) -- co-body 1 10
    local r = foo(a + 1)  --协程停止
    
    print("第二次协同程序执行输出", r)
    local r, s = coroutine.yield(a + b, a - b)  -- a，b的值为第一次调用协同程序时传入   --resume
    
    print("第三次协同程序执行输出", r, s)
    return b, "结束协同程序"                   -- b的值为第二次调用协同程序时传入
end)
       
print("main", coroutine.resume(co, 1, 10)) -- true, 4
print("--分割线----")
print("main", coroutine.resume(co, "r")) -- true 11 -9
print("---分割线---")
print("main", coroutine.resume(co, "x", "y")) -- true 10 end
print("---分割线---")
print("main", coroutine.resume(co, "x", "y")) -- cannot resume dead coroutine
print("---分割线---")

第一次协同程序执行输出	1	10
foo 函数输出	2
main	true	4
--分割线----
第二次协同程序执行输出	r
main	true	11	-9
---分割线---
第三次协同程序执行输出	x	y
main	true	10	结束协同程序
---分割线---
main	false	cannot resume dead coroutine
---分割线---

上面的例子更复杂了，而且出现了一个我没意料到的情况：

第二次协同程序执行输出	r

在第一次协程执行时，r应当等于4，而现在我们将输入的字符“r”赋值给了它，这就意味着第二次执行协程的时候，第一次的r很可能才被我们的入参"r"赋值，让我们验证一下：

function foo (a)
    print("foo 函数输出", a)
    return coroutine.yield(2 * a) -- 返回  2*a 的值
end
 
co = coroutine.create(function (a , b)
    print("第一次协同程序执行输出", a, b) -- co-body 1 10
    local r = foo(a + 1)  --去掉local声明不影响结果，不是local的原因
     
    print("第二次协同程序执行输出", r)
end)
       
print("main", coroutine.resume(co, 1, 10)) -- true, 4
print("--分割线----")
print("main", coroutine.resume(co))
输出：
第一次协同程序执行输出	1	10
foo 函数输出	2
main	true	4
--分割线----
第二次协同程序执行输出	nil

在协程进入suspend之后，这回我们不传入参数，输出结果是nil而非4。
也就是说return coroutine.yield(2 * a)语句，并不会将yield内的内容返回给return，而且它们的执行顺序是先执行coroutine.yield后执行return。其流程是：coroutine.yield -> 等待resume->resume回传入参给yield ->return 执行，返回这个入参，传入多个参数验证：

function foo (a)
    print("foo 函数输出", a)
    return coroutine.yield(2 * a) -- 返回  2*a 的值
end
 
co = coroutine.create(function (a , b)
    print("第一次协同程序执行输出", a, b) -- co-body 1 10
    local r,v = foo(a + 1)
    print("r",r,"v",v)
end)
       
print(coroutine.resume(co, 1, 10)) -- true, 4
print(coroutine.resume(co,5,20))
输出：
第一次协同程序执行输出	1	10
foo 函数输出	2
true	4
r	5	v	20
true

因此，这意味着协程中的接收return...yield的变量，在yield之后其返回值实际上是我们resume再回传回去的，而回传的参数将被return接收，所以return...yield都需要我们手动进行定义/传参，现在我能理解之前的例子了：

function foo (a)
    print("foo 函数输出", a)
    return coroutine.yield(2 * a) -- 返回  2*a 的值
end
 
co = coroutine.create(function (a , b)
    print("第一次协同程序执行输出", a, b) -- co-body 1 10
    local r = foo(a + 1)  --协程停止

    print("第二次协同程序执行输出", r)  --r需要传参
    r, s = coroutine.yield(a + b, a - b)  -- a，b的值为第一次调用协同程序时传入

    print("第三次协同程序执行输出", r, s)
    return b, "结束协同程序"                   -- b的值为第二次调用协同程序时传入
end)
       
print("main", coroutine.resume(co, 1, 10)) -- true, 4
print("--分割线----")
print("main", coroutine.resume(co, "r")) -- true 11 -9,"r"传入resume后的第一个变量r
print("---分割线---")
print("main", coroutine.resume(co, "x", "y")) -- true 10 end,"x","y"分别传入r,s
print("---分割线---")
print("main", coroutine.resume(co, "x", "y")) -- cannot resume dead coroutine
print("---分割线---")

输出：
第一次协同程序执行输出	1	10
foo 函数输出	2
main	true	4
--分割线----
第二次协同程序执行输出	r
main	true	11	-9
---分割线---
第三次协同程序执行输出	x	y
main	true	10	结束协同程序
---分割线---
main	false	cannot resume dead coroutine
---分割线---

所以对应的，resume的第一次传入参数是作为协程开启的函数入参，而之后的resume的传入参数将被yield接收。

宋瑞梁
关注
专栏目录
Lua的多任务机制——协程(coroutine)
歌谣在风中飘舞
03-24 3万+
    并发是现实世界的本质特征，而聪明的计算机科学家用来模拟并发的技术手段便是多任务机制。大致上有这么两种多任务技术，一种是抢占式多任务(preemptive multitasking)，它让操作系统来决定何时执行哪个任务。另外一种就是协作式多任务(cooperative multitasking)，它把决定权交给任务，让它们在自己认为合适的时候自愿放弃执行。这两种多任务方式各有优缺点，前者固有
Lua 的协程 为什么会出现？
TTc 's share
02-03 1047
一开始大家想要同一时间执行那么三五个程序，大家能一块跑一跑。特别是UI什么的，别一上计算量比较大的玩意就跟死机一样。于是就有了并发，从程序员的角度可以看成是多个独立的逻辑流。内部可以是多cpu并行，也可以是单cpu时间分片，能快速的切换逻辑流，看起来像是大家一块跑的就行。 但是一块跑就有问题了。我计算到一半，刚把多次方程解到最后一步，你突然插进来，我的中间状态咋办，我用来储存的内存被你覆盖了咋办
Lua基础(十六)协程 Coroutine
wzj_110的博客
01-12 978
高并发的核心
Lua语言入门
最新发布
yunyun1886358的专栏
07-06 1710
Lua 是一种高效的轻量级脚本语言。Lua 在葡萄牙语中是“月亮”的意思,它的徽标 形似卫星，寓意着Lua是一种“卫星语言”,能够方便地嵌入其他编程语言中使用。lua语法简单，小巧，源码一共才200多K，本身不会有太强的功能。 本文介绍了Lua语言基础，开发环境搭建，基础库，下载依赖库，本地构建Lua解释器，包管理LuaRocks
lua协程
blade2001的专栏
05-22 3839
lua里面协程最大好处,是把异步过程,当作同步处理协程是这样推导出来的： 首先，我么需要一个例程的概念，也就是函数或者过程。然后，我们会有调用和被调用这个关系。 由于结构化思想的流行，慢慢的稳定在一个例程就一个入口一个出口，调用者和被调用者是层次嵌套的关系。虽然，这个概念非常强大了，但是，这个想法明明有些概念不好表达，最好的例子就是： 一个例程，用来生成一个无穷序列，另一个例程，处理这个序
Lua协程
Martin的博客
01-14 1289
目录 1.什么是协程 1.1 进程和线程 1.2 协程 1.2.1 协程挂起与唤醒 1.3 进程、线程和协程的区别 2.Lua协程 协程是追求极限性能和优美的代码结构的产物，协程允许我们写同步代码的逻辑，却做着异步的时，避免了回调嵌套，使得代码逻辑清晰。 1.什么是协程 1.1 进程和线程 在了解什么是协程之前，我们先要了解什么是进程和线程。 进程是应用程序的启动实例，比如我...
Lua中的协程
NeverBeBack
10-28 873
lua中协程学习及坑点分享
Lua的协程
sindyra的博客
08-09 281
Lua的协程
lua中的协程
coder
04-16 1573
协程,也叫协同式多线程,跟普通的多线程一样,一个协程就代表了一条独立的执行序列.协程和普通多线程的区别在于:    普通的多线程,也叫抢占式多线程,意味着线程间的调度通常是由操作系统来完成；    而协程间的调度并不通过操作系统,而是由当前运行的协程显式的进行切换.lua实现的协程是一种非对称式协程(asymmetric coroutine),这种协程机制需要通过两个函数来控制协程的执行,一个用于...
Lua学习笔记（四）—— 协同程序的参数传递
腼腆纯朴、程序猿 的专栏
07-15 902
1、 协同程序的参数传递 a) 在第一次调用resume的时候，并没有对应的yield在等待它时，所有传递给resume的额外参数都将视为协同程序主函数的参数 co = coroutine.create(function (a,b,c) print("co",a,b,c) end) coroutine.resume(co,1,2,3)   b) 在resume调用返回的内容中，第
lua学习笔记（2）——内核入口
beat anyone if necessary
06-13 1728
lua.c:595 main()luaL_newstate(); //create new stack L lua_pushcfunction(L, &pmain); //push pmin into L lua_pushinteger(L, argc); //push argc into L lua_pushlightuserd
Lua学习笔记之类型与值
09-22
Lua的类型与值的学习笔记为我们提供了对这些基础知识的全面了解，对于Lua新手来说是一份宝贵的资料。通过这些知识点的学习，开发者可以更加有效地编写Lua程序，并在日常开发中避免一些常见错误。
通过例子学习LUA编程.doc lua进阶 实例代码
09-04
通过例子学习LUA编程.doc lua进阶 实例代码 有用 ，分享给大家
Lua学习笔记（六）—— 数组与集合
腼腆纯朴、程序猿 的专栏
07-15 4702
一、 数组 a) 新建一个数组   b) 用长度操作符（#）来获取数组的长度   c) 可以使用0、1或其他任意值来作为数组的起始索引   d) 可以使用0、1或其他任意值来作为数组的起始索引   e)  二、 矩阵与多维数组 a) 有两种方式来表示数组 i. 第一种，使用“数组的数组”   ii. 第二种，将两个索引合并为一个索引 1. 如果索引是整数   2.
lua 协程
weixin_43931625的博客
06-16 603
lua 协程
【Lua】协程
qq_38243831的博客
09-24 538
从多线程的角度看，协程（Coroutine）与线程（thread）类似：协程是一系列的可执行语句，拥有自己的栈、局部变量和指令指针，同时协程又与其它协程共享全局变量和其它几乎一切资源。线程和协程的主要区别：一个多线程程序可以同时并行运行多条线程，而协程却需要彼此协作地运行，即在任意时刻只能有一个协程运行，且协程的切换是在用户态手动控制的，只有当正在运行的协程显示的要求被挂起（suspend）时，其执行才会暂停。
Lua 协程
JunChow
11-29 255
并发是现实世界的本质特征，而聪明的计算机科学家用来模拟并发的技术手段便是多任务机制。多任务机制大致可划分为两种： 抢占式多任务（preemptive multi tasking） 抢占式多任务让操作系统来决定合适执行哪个任务 协作式多任务（cooperative multi tasking） 协作式多任务将决定权交给任务，让它们在自己任务合适的时候自愿放弃执行。 这两种度偶任务...
Lua调试库详解：进阶教程
“Lua 进阶教程（一）调试”涵盖了Lua语言中的调试技术，通过调试库为用户提供了创建自定义调试器的工具。教程中详细介绍了调试库中的多个功能，如进入交互式调试模式、获取环境、钩子设置、函数信息、局部变量、元...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值