This repo talks about asynchronous IO and its solution in Python, which is called coroutines.

由于CPU的速度远远快于磁盘、网络等IO, 在一个thread中, CPU执行代码的速度极快, 然而一旦遇到IO操作, 如读写文件、发送网络数据时, 就需要等待IO操作才能完成, 才能继续进行下一步操作.

=> 同步IO

=> 在IO过程中, 当前thread被挂起, 而其他需要CPU执行的代码就无法被当前thread执行了

• 一种解决办法: 使用multi-processing / multi-threading模型来并发执行代码

  为多个用户服务, 每个用户都会分配一个thread, 如果遇到IO导致thread被挂起, 其他用户的thread不受影响

• 另一种解决办法: 异步IO

  当代码需要执行一个耗时的IO操作时, 它只发出IO请求, 并不等待IO结果, 然后就去执行其他代码了; 一段时间后, 当IO结果返回时, 再通知CPU进行处理

  注意: 对于CPU密集型任务, 使用异步IO并不能加快程序运行, 因为CPU本身并没有在等待.

同步 vs 异步: 关注的是消息通信机制

阻塞 vs 非阻塞: 关注的是程序在等待调用结果时的状态

协程由同一个thread执行

协程看上去也是子程序, 但执行过程中, 在子程序 (协程) 内部可中断, 然后转而执行别的子程序 (协程) , 在适当的时候再返回来接着执行

def A(): print('1') print('2') print('3') def B(): print('x') print('y') print('z') # 假设由协程执行, 在执行A()的过程中, 可以随时中断, 去执行B(), B()也可能在执行过程中中断再去执行A(), 结果可能是: # 1 # 2 # x # 3 # y # z

thread的上下文切换是由操作系统来完成, 而协程的上下文切换是由应用程序本身来完成

具体例子参见以下Python module:

• simple_yield.py

• yield_from.py

• yield_from_and_asyncio.py

  用asyncio提供的@asyncio.coroutine可以把一个generator标记为coroutine类型, 然后在coroutine内部yield from调用另一个coroutine实现异步操作

  ---

  用这种方式实现的coroutine本质上是一个"generator-based coroutine", 二者的实现看起来很相似, 而其区别在于:

  • Generators produce data for iteration;
  • Coroutines tend to consume value, i.e., coroutines are not related to iteration.

  ---

• async_and_await.py

  本质上是一个syntax sugar, 用async def / await来代替之前的@asyncio.coroutine / yield from

  即: 使用await <coroutine>来asynchronously等待一个coroutine执行完毕, 而在使用了await语句的函数中, 函数的定义必须加上async, 即async def ..., 而这样一来这个函数本身也返回一个coroutine

• 注意, asyncio中也提供了各种Queue的实现来帮助在coroutine之间通信, 参见:

  comm_via_queue.py

• Greenlet is a light-weight cooperatively-scheduled execution unit.

  =>Greenlet就像一个coroutine

• 像asyncio一样, 在gevent (greenlet) 内部, 有一个event loop来执行Greenlet, 只不过使用了来自第三方的性能更好的event loop实现

Coroutines can be used to set up pipes.

• You just chain coroutines together and push data through the pipe with send() operation.
• If you built a collection of simple data processing components, you can glue them together into complex arrangemenets of pipes, branches, merging, etc.

The pipeline needs:

• A source (producer)

  The source drives the entire pipeline

  def source(target): while not done: item = produce_an_item() ... target.send(item) ... target.close()

  It is typically not a coroutine.

• Intermediate coroutines

  @coroutine def filter(target): try: while True: item = yield # Data filtering/processing ... target.send(item) except GeneratorExit as e: target.throw(e)

• A sink (consumer)

  Collects all data sent to it and process

  @coroutine def sink(): try: while True: item = yield ... except GeneratorExit: # Handle close() operation # Done ...

具体例子参见 Curious Course on Coroutines and Concurrency文件夹中:

• copipe.py
• cobroadcast.py

Coroutines can be used to write various components that process event streams.

具体例子参见Curious Course on Coroutines and Concurrency文件夹中:

• basicsax.py & cosax.py
• cosax_bus.py

One interesting thing about coroutines is that you can push the initial data source as low-level as you want to make it without rewriting all of the processing stages.

• coexpat_bus.py

Related note: Non-blocking model & asynchronous I/O in Node.js

For Node.js:

Single-threaded + Event-driven model (including an event loop) => Natively non-blocking I/O model

-> 只执行I/O请求, 而不等待I/O结果 => 大部分功能靠callback function实现

Check out https://github.com/Ziang-Lu/JavaScript-Learning-Notes/blob/master/node-crash-course/Node.md#non-blocking-io-model--asynchronous-io-in-nodejs

This repo is distributed under the MIT license.