Lua学习笔记-day8: 协同程序(coroutine)

[]Lua协同程序(coroutine)

1. 特点：

   1. 拥有独立的堆栈、独立的局部变量和独立的指令指针。

   2. 与其他协同程序共享全局变量和其他大部分东西。

2. 线程和协同程序的区别：

   1. 具有多个线程的程序，多个线程可以同时运行；但是具有多个协程的程序，同一时刻只能有一个协程运行。

3. 基本语法：

   1. coroutine.create()

      1. 功能：创建coroutine；

      2. 参数：一个函数，coroutine运行时，实际运行的是该函数。与coroutine.resume()配合使用。

      3. 返回值：coroutine；

   2. coroutine.resume()

      1. 功能：重新运行指定的coroutine；

      2. 参数：

         1. coroutine：指定需要重新运行的coroutine；

         2. 其他参数：根据功能需要，可传入任意值，该参数列表会作为yield()的返回值。

      3. 返回值：

         1. true/false：本次resume操作的结果。当协程执行完成后，再次resume，会返回false；

         2. 其他参数：coroutine.yield()的参数列表。

   3. coroutine.yield()

      1. 功能：挂起当前运行的coroutine，将当前coroutine设置为suspend状态；

      2. 参数：根据功能需要，可传入任意值，该参数列表会作为resume()的返回值。

      3. 返回值：coroutine.resume()的参数列表。

   4. coroutine.status():

      1. 功能：查看指定coroutine的运行状态。

      2. 参数：coroutine。

      3. 返回值(coroutine的运行状态）:

         1. suspended: 挂起状态。通过coroutine.create()刚创建的coroutine处于该状态。

         2. running: 运行状态。

         3. dead: coroutine的函数运行结束后，coroutine处于该状态。

   5. coroutine.running()：

   6. coroutine.wrap()

      1. 功能：创建coroutine；

      2. 参数：一个函数；

      3. 返回值：一个函数。调用该函数时，该coroutine就运行了。

4. 示例1：关于协程的三种状态。

   1. function funcTest()

      1. print(coroutine.status(co)) --该协程通过resume唤醒后，处于running状态。

   2. end

   3. co = coroutine.create(funcTest) --创建coroutine。

   4. coroutine.status(co) --新创建的coroutine处于suspended状态。

   5. coroutine.resume(co) --唤醒指定协程。

   6. coroutine.status(co) --协程函数运行完成，此时coroutine处于dead状态。

5. 示例2：关于yield和resume的参数和返回值。

   1. function funcTest()

      1. res1, res2, res3 = coroutine.yield('y11', 'y22', 'y33')

      2. print(res1, res2, res3) --依次输出：'r11', 'r22', 'r33'

      3. return

   2. end

   3. co = coroutine.create(funcTest) --创建协程

   4. status, y1, y2, y3 = coroutine.resume(co, 'r1', 'r2', 'r3') --唤醒协程；本次resume调用的参数('r1', 'r2', 'r3')无用！

   5. print(status, y1, y2, y3) --依次输出：true, 'y11', 'y22', 'y33'，也就是yield的参数列表。

   6. status, y1, y2, y3 = coroutine.resume(co, 'r11', 'r22', 'r33') --

   7. print(status, y1, y2, y3)--依次输出：true, nil, nil, nil

   8. 总结：

      1. resume一般运行在主程中，通过resume的参数列表将外部状态传入到协同程序内部；

      2. yeild一般运行在协程内，通过yield的参数列表将协程内部的状态传入到主程中。

6. 示例3：生产者与消费者。

   1. local coProdutor

   2. function funcProdutor()

      1. for i = 1, 10 do

         1. coroutine.yield(i) --生产者运行在协程内，每次向主程返回i的值。

      2. end

   3. end

   4. function funcConsumer()

      1. while true do

         1. status, value = coroutine.resume(coProdutor) --消费者运行在主程内，唤醒生产者生产数据后，进行打印处理。

         2. print("[con]", "status:", status, "value:", value)

         3. if false == status then --如果生产者不再生产数据，消费者退出。

            1. break

         4. end

      2. end

   5. end

   6. coProdutor = coroutine.create(funcProdutor) --创建生产者协程

   7. funcConsumer() --启动消费者