Python和JavaScript中的生成器与协程

发表于 | 分类于 | 269
字数统计 1.6k | 阅读时长 6

0x00 前言

Python和JavaScript中都有生成器（Generator）和协程（coroutine）的概念。本文通过分析两者在这两种语言上的使用案例，来对比它们的差异。

0x01 Python中的生成器

Python中的生成器简介

使用过Python的同学对生成器的概念应该是很熟悉的，一个经典的例子是使用它生成斐波拉契数列。

  1. def fab(max):
  2.     n, a, b = 0, 0, 1
  3.     while n < max:
  4.         yield b
  5.         a, b = b, a + b
  6.         n = n + 1
  COPY

输出结果如下：

  1. >>> for n in fab(5):
  2. ...     print n
  3. ...
  4. 1
  5. 1
  6. 2
  7. 3
  8. 5
  COPY

在Python中，使用了yield的函数不再是普通函数，而是一个生成器函数，执行它返回的是一个生成器对象，可以进行迭代，可以调用next函数获取下一个值。

  1. >>> fab
  2. <function fab at 0x0225E4F0>
  3. >>> fab(5)
  4. <generator object fab at 0x0217BE18>
  5. >>> x=fab(5)
  6. >>> x.next()
  7. 1
  8. >>> x.next()
  9. 1
  10. >>> x.next()
  11. 2
  12. >>> x.next()
  13. 3
  14. >>> x.next()
  15. 5
  COPY

yield也支持使用send方法进行参数传递。

  1. def gen_test():
  2.     n = 1
  3.     while True:
  4.         n = yield n
  5.         print n
  7. g = gen_test()
  8. n = g.next()
  9. for i in range(5):
  10.     n = g.send(n * 2)
  COPY

输出结果为：

  1. 2
  2. 4
  3. 8
  4. 16
  5. 32
  COPY

创建生成器函数后，需要先调用一次next函数，否则程序会报以下错误：

  1. TypeError: can't send non-None value to a just-started generator
  COPY

yield最大的特点是允许代码发生中断，并在调用next或send时继续往下执行。

Python中使用生成器实现协程

协程是一种通过代码实现的模拟多线程并发的逻辑，其特点是使用一个线程实现了原本需要多个线程才能实现的功能；而且由于避免了多线程切换，提升了程序的性能，甚至去掉了多线程中必不可少的互斥锁。

协程最大的一个特点是用同步的方式写异步代码，提升了代码的可读性，并降低了维护成本。

协程与多线程的主要差别如下：

  1. 协程只有一个线程，多线程有多个线程
  2. 协程中任务（逻辑线程）的切换是在代码中主动进行的；线程的切换是操作系统进行的，时机不可预期
  3. 进程中可以创建的线程数量是有限的，数量多了之后产生的线程切换开销比较大；协程可以创建的任务数量主要受CPU占用率、文件句柄数量等限制

由于Python中GIL的存在，多线程实际上并无法利用到多核CPU的优势。这种情况下使用协程 + 多进程无疑是最优实现方案。

yield天生的特性，为实现协程提供了极大的便利。

Python中使用生成器实现协程的典型库是：tornado。即便是自己实现也不是很复杂，基本原理就是维护一个事件队列，保存生成器对象，不断取出队列前面的生成器对象，去调用send方法，进行参数传递，从而维护了函数调用链。

下面是使用tornado的一个例子：

  2. import tornado.gen
  3. import tornado.ioloop
  4. import tornado.tcpclient
  6. @tornado.gen.coroutine
  7. def tcp_client_demo(addr, port):
  8.     tcp_client = tornado.tcpclient.TCPClient()
  9.     stream = yield tcp_client.connect(addr, port, timeout=30)
  10.     stream.write('send data')
  11.     buffer = yield stream.read_until('\r\n\r\n')
  12.     raise tornado.gen.Return(buffer)
  14. tcp_client_demo('1.1.1.1', 1111)
  15. tornado.ioloop.IOLoop.current().start()
  COPY

不过tornado中还是有很多地方需要写回调函数的，个人觉得这些地方实现得不是很优雅。

Python从3.5开始支持async和await关键字，从而在语言层面支持了协程。但是使用生成器实现协程的兼容性会更好。

0x02 JavaScript中的生成器

JavaScript中的生成器简介

JavaScript中可以使用function*创建生成器函数，这是在ES6规范中提出来的，Chrome从版本39才开始支持这一特性。

使用JavaScript生成斐波拉契数列的代码如下：

  1. function* fab(max) {
  2.     var [n, a, b] = [0, 0, 1];
  3.     while(n < max) {
  4.         yield b;
  5.         [a, b] = [b, a + b];
  6.         n++;
  7.     }
  8. }
  COPY

执行结果如下：

  1. > x=fab(5)
  2. fab {[[GeneratorStatus]]: "suspended"}
  3. > x.next()
  4. Object {value: 1, done: false}
  5. > x.next()
  6. Object {value: 1, done: false}
  7. > x.next()
  8. Object {value: 2, done: false}
  9. > x.next()
  10. Object {value: 3, done: false}
  11. > x.next()
  12. Object {value: 5, done: false}
  COPY

可以看出，使用方法与Python中是基本一致的，不过，JavaScript中并没有send方法，但是next是可以传参的，相当于结合了Python中next和send的功能。

JavaScript中使用生成器实现协程

JavaScript天生是一个单线程的环境，一般不能使用阻塞的操作，传统的实现多采用异步回调（callback）方式。但是，这种方式容易导致层层嵌套，变成回调地狱（Callback Hell），阅读和调试都不是很方便。

后来出现了Promise，可以用优雅一些的方法编写异步代码，但是仍然不够优雅。于是出现了基于生成器和Promise实现的co库，这个库目前只有200多行代码，可以将生成器函数变成Promise对象，并自动执行。它支持yield一个Promise对象，其效果与async和await（Chrome 55开始支持）相似。

co代码链接为：https://github.com/tj/co/blob/master/index.js。

关于co的具体介绍可以参考这篇文章。

以下是使用co的一个例子：

  2. function sleep(ms) {
  3.   return new Promise(resolve => setTimeout(resolve, ms));
  4. }
  6. function* gen_sleep() {
  7.     console.log(new Date());
  8.     yield sleep(2000);
  9.     console.log(new Date());
  10. }
  12. co(gen_sleep);
  COPY

执行结果如下：

  1. Wed Jul 18 2018 14:39:44 GMT+0800 (中国标准时间)
  2. Promise {[[PromiseStatus]]: "pending", [[PromiseValue]]: undefined}
  3. VM514:8 Wed Jul 18 2018 14:39:47 GMT+0800 (中国标准时间)
  COPY

这里两次打印时间差了3秒，怀疑是执行误差所致。使用async和await也是如此，尚未找到具体原因。

如果只是不断调用gen_sleep的next函数，是不会进行sleep操作的。

使用async和await实现以上的功能，代码如下：

  2. function sleep(ms) {
  3.   return new Promise(resolve => setTimeout(resolve, ms));
  4. }
  6. async function async_sleep() {
  7.     console.log(new Date());
  8.     await sleep(2000);
  9.     console.log(new Date());
  10. }
  12. async_sleep();
  COPY

可以看出，这两种方式都可以实现协程的效果，但是后者是语言官方支持，应该会成为主流。

0x03 总结

从上面的例子可以看出，两者对生成器和协程的使用有很多相似之处，可以说是大同小异。在理解了语言的这些特性之后，编写协程代码会更加地轻松。

总的来说就是：语言都是相通的。

分享

Related Issues not found

Please contact @drunkdream to initialize the comment