协程Coroutine相关资料汇集 – Python/Lua

http://www.inf.puc-rio.br/~roberto/docs/corosblp.pdf
Coroutines in Lua
Ana L´ucia de Moura , Noemi Rodriguez , Roberto Ierusalimschy

http://www.inf.puc-rio.br/~roberto/docs/MCC15-04.pdf
Revisiting Coroutines
Ana L´ucia de Moura and Roberto Ierusalimschy

http://ravenw.com/blog/2011/08/24/coroutine-part-1-defination-and-classification-of-coroutine/
协程(一)协程的定义与分类
协程的概念最早由Melvin Conway在1963年提出并实现,用于简化COBOL编译器的词法和句法分析器间的协作,当时他对协程的描述是“行为与主程序相似的子例程”。

http://ravenw.com/blog/2011/09/01/coroutine-part-2-the-use-of-coroutines/
协程(二):协程的应用
Conway提出协程这个概念时所解决的编译器问题就属于生产者-消费者问题。
生成器实际上可以看作只有生产者的生产者-消费者模型。
目标导向编程是指模式匹配(Pattern-matching)或Prolog的查询这样的系统,由用户提出一个形式化定义的目标(Goal),系统会在一系列可选的子目标中寻找直到确认一个解决方案。在寻找过程中常常会需要回溯(Backtracking)机制,这种机制使用完全非对称协程作为生成器很容易实现。
在并发编程中,协程与线程类似,每个协程表示一个执行单元,有自己的本地数据,与其它协程共享全局数据和其它资源。目前主流语言基本上都选择了多线程作为并发设施,与线程相关的概念是抢占式多任务(Preemptive multitasking),而与协程相关的是协作式多任务。

http://ravenw.com/blog/2011/09/06/coroutine-part-3-coroutine-and-continuation/
协程(三)协程与Continuation
Continuation是一种描述程序的控制状态的抽象,它用一个数据结构来表示一个执行到指定位置的计算过程;这个数据结构可以由程序语言访问而不是隐藏在运行时环境中。Continuation在生成之后可作为控制结构使用,在调用时会从它所表示的控制点处恢复执行。

http://simple-is-better.com/news/426
Gevent 任务的持续追加和执行

http://simple-is-better.com/news/363

http://blog.jqian.net/coroutine.html

http://gashero.iteye.com/blog/442177
协程才是未来-性能夸张的协程服务器,基于eventlet(greenlet)的http性能测试

http://blog.csdn.net/lanphaday/article/details/5397038
协程三篇之一(协程初接触)

http://codeprac.iteye.com/blog/1060778
coroutine资源索引
c语言中实现coroutine有以下几种方法

http://en.wikipedia.org/wiki/Generator_%28computer_programming%29
Python相关概念

http://fuliang.iteye.com/blog/857644
Ruby Coroutine
Ruby1.9提供了Fiber,提供了Coroutine的功能。
Fibers作为实现轻量级合作并发的基础设施,和线程很像,提供了创建一个可以pause和resume的代码块,但Fibers是非抢占式的,必须由程序而不是VM来调度。每一个fiber提供了4kB的栈空间可以允许fiber的block进行深层嵌套函数调用。这是rdoc对Fiber的描述。

http://www.dabeaz.com/coroutines/index.html
A Curious Course on Coroutines and Concurrency
http://www.dabeaz.com/coroutines/Coroutines.pdf

http://www.python.org/dev/peps/pep-0342/
Coroutines via Enhanced Generators

http://lua-users.org/wiki/LuaCoroutinesVersusPythonGenerators
How do Python generators differ from Lua coroutines?
http://sunxiunan.com/?p=1654
【译文】比较Lua协程与Python生成器
Lua最重要的特性,coroutine.yield()是个一般函数,可以在coroutine.resume()动态扩展的任意位置被调用,限制是你不能yield操作C回调函数(除非你使用了Coco库)。在Python中,yield是一个语法,只能在生成器(generator)的语句体里存在。

Some Python Projects:
http://www.gevent.org/
http://codespeak.net/py/0.9.2/greenlet.html
https://github.com/slideinc/gogreen
https://github.com/j2labs/brubeck
https://github.com/sampsyo/bluelet

—————–
Lua
—————–

http://lua-users.org/wiki/CoroutinesTutorial

Lua5.1 Coroutine
http://www.lua.org/manual/5.1/manual.html#2.11

Lua5.2 Coroutine
http://www.lua.org/work/doc/manual.html#2.6
http://www.lua.org/work/doc/manual.html#6.2

http://lua-users.org/wiki/MultiTasking

http://kotisivu.dnainternet.net/askok/bin/lanes/index.html
Lua Lanes

http://keplerproject.github.com/copas/manual.html#introduction
如果想实战使用的可以试试copas

http://sunxiunan.com/?p=1689
使用Lua协程实现斐波拉切

http://mryufeng.iteye.com/blog/211650
luacoco 增强lua的coroutine功能

http://mryufeng.iteye.com/blog/211004
lua coroutine是如何实现的?
lua的coroutine是通过c的堆栈来保存调用上下文的 多少个coroutine嵌套 就有多少个luaV_execute, 而lua的state保存存在lua_State,也就是thread对象中。
顺着调用链 再看下源代码很容易就明白了。

http://sunxiunan.com/?p=1793
Re [CPyUG] Coroutine协程和闭包本质上有什么区别么
就我个人浅见,闭包概念比较容易理解使用,而协程是一个动态交互的动作,涉及到主程序和协程子程序之间的交换,理解起来要麻烦多多。

http://timyang.net/lua/lua-coroutine/
TimYang
协同程序与线程差不多,也就是一条执行序列,拥有自己独立的栈,局部变量和指令指针,同时又与其它协同程序共享全局变量和其它大部分东西。线程与协同程序的主要区别在于,一个具有多线程的程序可以同时运行几个线程,而协同程序却需要彼此协作地运行。就是说,一个具有多个协同程序的程序在任何时刻只能运行一个协同程序,并且正在运行的协同程序只会在其显示地挂起时,它的执行才会暂停。

http://blog.codingnow.com/2011/08/lua_52_multithreaded.html
coroutine 可以实现一个协同多线程模型。即,每个线程(coroutine) 只在用户期望的地方跳出来,并可以在以后跳回去(保持当初跳离的状态)。这解决了许多抢占式多线程的麻烦。lua 的发明人在一篇访谈中谈到了 coroutine 解决并发的问题。
lua vm 本身的状态可以保留在 L 中,但 C 函数的状态却丢失了,无法正确返回。Lua 5.2 为了解决这个问题,引入了新的 api ,有兴趣可以阅读新的文档的 4.7 – Handling Yields in C
lua 的早期版本也可以通过 lua coco 实现无限制的 yield 操作。但 coco 使用了 OS 的 fiber 库 这比 5.2 版的 lua 实现多出了额外的堆栈开销。

http://blog.codingnow.com/2010/12/lua_cothread.html
基于 lua 的 coroutine ,只是写了个简单的调度器。

http://blog.codingnow.com/2010/06/masterminds_of_programming_7_lua.html
打算如何处理并发问题?
使用协程(coroutine),我们可以共享内存,但不是抢占式的。不过这个技术利用不到多核机器。但在这类机器上,使用多“进程”就能极大的发挥其性能。这个我提到的“进程”是指在 C 里的一个线程,这个线程维护自己独立的 Lua 状态机。这样,在 Lua 层面上,就没有内存共享使用。在《Lua 程序设计第二版》[Lua.org] 中,我给出了这种方式的一个原型。最近我们已经看到有些库支持了这种方式(比如 Lua Lanes 以及 luaproc)。

没有支持并发,但你为多任务实现了一个有趣的解决方案:非对称式协程。它们如何工作的?
Luiz:在我们的 HOPL 论文中,对那些设计决策全部做了极为详细的解释说明。
Roberto:我们最终选择了非对称式模型。它的基本思想非常简单。通过显式调用 coroutine.create 函数来创建一个协程,把一个函数作为协程主体来执行。当我们启动 (resume) 协程时,它开始运行函数体并且直到结束或者让出控制权 (yield) ;一个协程只有通过显式调用 yield 函数才会中断。以后,我们可以 resume 它,它将会从它停止的地方继续执行。
它的基本思想非常类似于 Python 的生成器,但有一个关键区别:Lua协程可以在嵌套调用中 yield,而在 Python 中,生成器只能从它的主函数中 yield。在实现上,这意味着每个协程像线程一样必须有独立堆栈。和“平坦”的生成器相比,“带堆栈”的协程发挥了不可思议的强大威力。例如,我们可以在它们的基础上实现一次性延续点 (one-shot continuations)。

http://blog.codingnow.com/2011/12/dev_note_4.html
这套东西的框架其实是一个 coroutine 的调度器。每个执行流(就是 case message),不论是不是并行的,都是一个 coroutine 。当遇到 listen ,fork ,break 的时候 coroutine yield 出来,由调度器来决定下一步该 resume 哪个分支就好了。
框架只需要接收外界传入的带类型信息的 message ,在调度器里维护一张消息类型到执行流的映射表,就可以正确的调度这些东西。

https://github.com/lefcha/concurrentlua

http://www.lua.inf.puc-rio.br/luagravity/
The link and await primitives are the supported reactivity mechanisms of LuaGravity. 类似C#的await

http://coco.luajit.org/
Lua的协程功能不支持C函数扩展,那么可以试试大名鼎鼎的LuaJit作者出品的Coco

关于Green Thread(绿色环保线程)、Native Thread,以及线程的一些普及问题,下面这个presentation很不错(关于Ruby)
http://www.slideshare.net/tmm1/threaded-awesome-1922719

维基百科上的这一条
http://en.wikipedia.org/wiki/Thread_%28computer_science%29

http://c2.com/cgi/wiki?SameFringeProblem
here’s the killer example of the utility of CoRoutines. The problem setup is quoted from RichardGabriel’s 1991 paper “The Design of Parallel Programming Languages” (http://www.dreamsongs.com/10ideas.html)

http://code.google.com/p/js-coroutine/
Lua style coroutine support for V8 JavaScript

《协程Coroutine相关资料汇集 – Python/Lua》有2个想法

发表评论