Python 协程

1. 协程介绍

什么是协程？

协程，又称微线程，纤程。英文为 Coroutine。

协程其实可以认为是比线程更小的执行单元。为啥说他是一个执行单元，因为它自带 CPU 上下文。这样只要在合适的时机，我们可以把一个协程切换到另一个协程。只要这个过程中保存或恢复 CPU 上下文，那么程序还是可以运行的。

通俗的理解：在一个线程中的某个函数，可以在任何地方保存当前函数的一些临时变量等信息，然后切换到另外一个函数中执行，注意不是通过调用函数的方式做到的，并且切换的次数以及什么时候再切换到原来的函数都可以由开发者自己确定。

协程 VS 进程 VS 线程

协程 VS 进程

执行流的调度者不同。无论多线程和多进程，其调度更多取决于操作系统；而协程的方式，调度来自用户。也就是说进程的上下文是在内核态保存恢复的，而协程是在用户态保存恢复的，显然用户态的代价更低。
进程会被强占；而协程不会，也就是说协程如果不主动让出 CPU，那么其他的协程就没有执行的机会。
对内存的占用不同。实际上协程可以只需要 4K 的栈就足够了；而进程占用的内存要大得多。
从操作系统的角度讲，多协程的程序是单进程单线程。

协程 VS 线程

协程看起来跟线程差不多，其实不然。线程切换从系统层面来看远不止保存和恢复 CPU 上下文这么简单。操作系统为了程序运行的高效性，每个线程都有自己缓存 Cache 等数据，操作系统还会帮你做这些数据的恢复操作，所以线程的切换非常耗性能。但是协程的切换只是单纯的操作 CPU 的上下文，所以一秒钟切换个上百万次，系统都抗得住。
同样的，线程的切换更多的是靠操作系统来控制，而协程的执行由我们自己控制。
协程只是在单一的线程下，不同的协程之间做切换；其实和多线程很像，多线程是在一个进程下，不同的线程之间做切换。

协程的问题

但是协程有一个问题，就是系统并不感知，所以操作系统不会帮你做切换。那么谁来帮你做切换？让需要执行的协程更多地获得 CPU 时间才是问题的关键。

协程框架

目前的协程框架一般都是设计成 1:N 模式。所谓 1:N 就是一个线程作为一个容器里面放置多个协程。那么谁来适时的切换这些协程？答案是由协程自己主动让出 CPU，也就是每个协程池里面有一个调度器，这个调度器是被动调度的，意思就是他不会主动调度。而且当一个协程发现自己执行不下去了（比如异步等待网络的数据回来，但是当前还没有数据到），这个时候就可以由这个协程通知调度器，调度器根据事先设计好的调度算法找到当前最需要 CPU 的协程。切换这个协程的 CPU 上下文，并把 CPU 的运行权交给这个协程，直到这个协程出现执行不下去需要等待的情况，或者它调用主动让出 CPU 的 API 等时，又再触发下一次的协程调度。

那么这个实现有没有问题？

其实是有问题的，假设这个线程中有一个协程是 CPU 密集型的，但它没有 I/O 操作，也就是自己不会主动触发调度器调度的过程，那么就会出现其他协程得不到执行的情况，所以这种情况下需要程序员自己避免。这是一个问题，假设业务开发的人员并不懂这个原理的话就可能会出现问题。

协程的好处

在 I/O 密集型的程序中由于 I/O 操作远远慢于 CPU 的操作，所以往往需要 CPU 去等 I/O 操作。同步 I/O 下系统需要切换线程，让操作系统可以在 I/O 过程中执行其他的东西。这样虽然代码是符合人类的思维习惯，但是由于大量的线程切换带来了大量的性能的浪费，尤其是 I/O 密集型的程序。

所以人们发明了异步 I/O，就是当数据到达的时候触发我的回调，来减少线程切换带来性能损失。但是这样的坏处也是很大的，主要的坏处就是操作被 “分片” 了，代码写的不是 “一气呵成” 这种，而是每次来段数据就要判断数据够不够处理，够处理就处理，不够处理就再等等吧。这样代码的可读性很低，也不符合人类的习惯。

但是协程可以很好解决这个问题。比如把一个 I/O 操作写成一个协程，当触发 I/O 操作的时候就自动让出 CPU 给其他协程，要知道协程的切换很轻的。协程通过这种对异步 I/O 的封装既保留了性能，也保证了代码的易编写和可读性。在 I/O 密集型的程序下很好（但是 CPU 密集型的程序下没啥好处）。

协程的优点

无需线程上下文切换的开销。协程执行效率极高，因为子程序（函数）切换不是线程切换，由程序自身控制，没有切换线程的开销。所以与多线程相比，线程的数量越多，协程性能的优势越明显。但也因此，程序员必须自己承担调度的责任，同时，协程也失去了标准线程使用多 CPU 的能力。
方便切换控制流，简化编程模型。
高并发+高扩展性+低成本：一个 CPU 支持上万个协程都不是问题，所以很适合用于高并发处理。

协程的缺点

无法利用多核资源：协程的本质是个单线程，它不能同时将单个 CPU 的多个核用上，协程需要和多进程/线程配合才能运行在多 CPU 上。
进行阻塞（Blocking）操作（如 I/O 时）会阻塞掉整个程序。
协程可以很好地处理 I/O 密集型程序的效率问题，但是处理 CPU 密集型不是它的长处，如要充分发挥 CPU 利用率可以结合多进程/线程+协程。

2. 协程-生成器版

 1 import time 
 2 
 3 
 4 def a():
 5     while True:
 6         print("---A---")
 7         yield 
 8         time.sleep(0.5)
 9         
10 def b(c):
11     while True:
12         print("---B---")
13         next(c)
14         time.sleep(0.5)
15         
16 
17 if __name__ == "__main__":
18     one = a()  # 返回迭代器对象
19     b(one)  # 在b函数中不断调用one.next()

运行结果：

---B---
---A---
---B---
---A---
---B---
---A---
---B---
---A---
.......

3. 协程-greenlet 版

为了更好使用协程来完成多任务，python 中的 greenlet 模块对其封装，从而使得切换任务变的更加简单。

需安装 greenlet 模块：pip install greenlet

示例：

 1 from greenlet import greenlet
 2 import time
 3 
 4 
 5 def test1():
 6     while True:
 7         print("---A---")
 8         gr2.switch()
 9         time.sleep(0.5)
10         
11 def test2():
12     while True:
13         print("---B---")
14         gr1.switch()
15         time.sleep(0.5)
16 
17 if __name__ == "__main__":        
18     gr1 = greenlet(test1)
19     gr2 = greenlet(test2)
20     gr1.switch()

运行结果：

---B---
---A---
---B---
---A---
---B---
---A---
---B---
---A---
.......

4. 协程-gevent 版

greenlet 已经实现了协程，但是这个还得人工切换，是不是觉得太麻烦了，python 还有一个比 greenlet 更强大的并且能够自动切换任务的模块 gevent。

其原理是当一个 greenlet 遇到 I/O操作时，像访问网络，就自动切换到其他的 greenlet，等到 I/O 操作完成，再在适当的时候切换回来继续执行。

由于 I/O 操作非常耗时，经常使程序处于等待状态，有了 gevent 为我们自动切换协程，就保证总有 greenlet 在运行，而不是等待 I/O。

gevent 的使用

python3 安装 gevent：python -m pip install -i https://pypi.tuna.tsinghua.edu.cn/simple gevent

示例：

 1 import gevent
 2 
 3 
 4 def f(n):
 5     for i in range(n):
 6         print(gevent.getcurrent(), i)
 7   
 8   
 9 g1 = gevent.spawn(f, 5)
10 g2 = gevent.spawn(f, 5)
11 g3 = gevent.spawn(f, 5)
12 g1.join()
13 g2.join()
14 g3.join()

运行效果：3 个 greenlet 依次运行，而不是交替运行

<Greenlet at 0x3b01bd8: f(5)> 0
<Greenlet at 0x3b01bd8: f(5)> 1
<Greenlet at 0x3b01bd8: f(5)> 2
<Greenlet at 0x3b01bd8: f(5)> 3
<Greenlet at 0x3b01bd8: f(5)> 4
<Greenlet at 0x3b01ce8: f(5)> 0
<Greenlet at 0x3b01ce8: f(5)> 1
<Greenlet at 0x3b01ce8: f(5)> 2
<Greenlet at 0x3b01ce8: f(5)> 3
<Greenlet at 0x3b01ce8: f(5)> 4
<Greenlet at 0x3b01d70: f(5)> 0
<Greenlet at 0x3b01d70: f(5)> 1
<Greenlet at 0x3b01d70: f(5)> 2
<Greenlet at 0x3b01d70: f(5)> 3
<Greenlet at 0x3b01d70: f(5)> 4

gevent 切换执行

示例1

 1 import gevent
 2 
 3 
 4 def f(n):
 5     for i in range(n):
 6         print(gevent.getcurrent(), i)
 7         # 用来模拟一个耗时操作，注意不是time模块的sleep
 8         # 当有耗时操作时，gevent就会自动切换去执行空闲的协程
 9         gevent.sleep(1)
10   
11   
12 g1 = gevent.spawn(f, 5)
13 g2 = gevent.spawn(f, 5)
14 g3 = gevent.spawn(f, 5)
15 g1.join()
16 g2.join()
17 g3.join()

运行效果：3 个 greenlet 交替运行

<Greenlet at 0x33f1bd8: f(5)> 0
<Greenlet at 0x33f1ce8: f(5)> 0
<Greenlet at 0x33f1d70: f(5)> 0
<Greenlet at 0x33f1bd8: f(5)> 1
<Greenlet at 0x33f1ce8: f(5)> 1
<Greenlet at 0x33f1d70: f(5)> 1
<Greenlet at 0x33f1bd8: f(5)> 2
<Greenlet at 0x33f1ce8: f(5)> 2
<Greenlet at 0x33f1d70: f(5)> 2
<Greenlet at 0x33f1bd8: f(5)> 3
<Greenlet at 0x33f1ce8: f(5)> 3
<Greenlet at 0x33f1d70: f(5)> 3
<Greenlet at 0x33f1bd8: f(5)> 4
<Greenlet at 0x33f1ce8: f(5)> 4
<Greenlet at 0x33f1d70: f(5)> 4

示例2

 1 import gevent
 2 
 3 
 4 def func1():
 5     print("Running in func1...")
 6     gevent.sleep(2)
 7     print("Explicit context switch to func1 again")
 8 
 9 def func2():
10     print("Running in func2...")
11     gevent.sleep(1)  # 假设遇到IO事件，则切换其它协程
12     print("Implicit context switch back to func2")
13 
14 def func3():
15     print("Running in func3...")
16     gevent.sleep(3)
17     print("running func3 again ")
18 
19 
20 if __name__=="__main__":
21     gevent.joinall([
22                     gevent.spawn(func1),
23                     gevent.spawn(func2),
24                     gevent.spawn(func3),
25                     ])

执行效果

Running in func1...
Running in func2...
Running in func3...
Implicit context switch back to func2
Explicit context switch to func1 again
running func3 again

gevent 并发下载器

当然，实际代码里，我们不会用 gevent.sleep() 去切换协程，而是在执行到 I/O 操作时，让 gevent 自动切换。实现代码如下：

 1 from gevent import monkey
 2 import gevent
 3 import urllib.request
 4 
 5 # 有I/O操作时需要这一句
 6 monkey.patch_all()
 7 
 8 def myDownload(url):
 9     print("get: %s" % url)
10     # 请求站点，获得一个HTTPResponse对象
11     response = urllib.request.urlopen(url)
12     data = response.read()
13     print("%d bytes received from: %s" % (len(data), url))
14     
15 gevent.joinall([
16     gevent.spawn(myDownload, "http://www.baidu.com"),
17     gevent.spawn(myDownload, "http://www.163.com"),
18     gevent.spawn(myDownload, "http://www.cnblogs.com"),
19 ])

执行效果：收到数据的先后顺序不一定与发送顺序相同，这也就体现出了异步，即不确定什么时候会收到数据，顺序不一定。

get: http://www.baidu.com
get: http://www.163.com
get: http://www.cnblogs.com
499227 bytes received from: http://www.163.com
199947 bytes received from: http://www.baidu.com
48149 bytes received from: http://www.cnblogs.com

posted @ 2020-03-21 14:27 Juno3550 阅读(174) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Juno3550

Python 协程

1. 协程介绍

2. 协程-生成器版

3. 协程-greenlet 版

4. 协程-gevent 版

1. 协程介绍

什么是协程？

协程 VS 进程 VS 线程

协程的问题

协程框架

那么这个实现有没有问题？

协程的好处

协程的优点

协程的缺点

2. 协程-生成器版

3. 协程-greenlet 版

4. 协程-gevent 版

gevent 的使用

gevent 切换执行

示例1

示例2

执行效果

gevent 并发下载器

公告