协程

1. 协程介绍

2. 协程简单实现

3.协程-greenlet版

4.协程-gevent版

 

 

1. 协程介绍

什么是协程？

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

协程其实能够认为是比线程更小的执行单元。 为啥说他是一个执行单元，由于他自带CPU上下文。这样只要在合适的时机， 咱们能够把一个协程切换到另外一个协程。只要这个过程当中保存或恢复 CPU上下文，那么程序仍是能够运行的。

通俗的理解：在一个线程中的某个函数，能够在任何地方保存当前函数的一些临时变量等信息，而后切换到另一个函数中执行，注意不是经过调用函数的方式作到的，而且切换的次数以及何时再切换到原来的函数都由开发者本身肯定。

协程和线程差别

这个过程看起来比线程差很少，其实否则。线程切换从系统层面来看远不止保存和恢复CPU上下文这么简单。操做系统为了程序运行的高效性，每一个线程都有本身缓存Cache等数据，操做系统还会帮你作这些数据的恢复操做，因此线程的切换很是耗性能。可是协程的切换只是单纯的操做CPU的上下文，因此一秒钟切换个上百万次系统都抗的住。

协程的问题

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

例子

目前的协程框架通常都是设计成 1:N 模式。所谓 1:N 就是一个线程做为一个容器里面放置多个协程。那么谁来适时的切换这些协程？答案是由协程本身主动让出CPU，也就是每一个协程池里面有一个调度器，这个调度器是被动调度的，意思就是他不会主动调度。并且当一个协程发现本身执行不下去了(好比异步等待网络的数据回来，可是当前尚未数据到)，这个时候就能够由这个协程通知调度器，这个时候执行到调度器的代码，调度器根据事先设计好的调度算法找到当前最须要CPU的协程。切换这个协程的CPU上下文把CPU的运行权交个这个协程，直到这个协程出现执行不下去须要等等的状况，或者它调用主动让出CPU的API之类，触发下一次调度。

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

实际上是有问题的，假设这个线程中有一个协程是CPU密集型的，但他没有IO操做， 也就是本身不会主动触发调度器调度的过程，那么就会出现其余协程得不到执行的状况，因此这种状况下须要程序员本身避免。这是一个问题，假设业务开发的人员并不懂这个原理的话就可能会出现问题。

协程的好处

在IO密集型的程序中因为IO操做远远慢于CPU的操做，因此每每须要CPU去等IO操做。同步IO下系统须要切换线程，让操做系统能够在IO过程当中执行其余的东西。这样虽然代码是符合人类的思惟习惯，可是因为大量的线程切换带来了大量的性能的浪费，尤为是IO密集型的程序。

因此人们发明了异步IO，就是当数据到达的时候触发个人回调，来减小线程切换带来性能损失。可是这样的坏处也是很大的，主要的坏处就是操做被 “分片” 了，代码写的不是 “一鼓作气” 这种，而是每次来段数据就要判断数据够不够处理，够处理就处理吧，不够处理就再等等吧。这样代码的可读性很低，其实也不符合人类的习惯。

可是协程能够很好解决这个问题。好比把一个IO操做写成一个协程，当触发IO操做的时候就自动让出CPU给其余协程，要知道协程的切换很轻的。协程经过这种对异步IO的封装既保留了性能也保证了代码的容易编写和可读性。在高IO密集型的程序下很好，可是高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遇到IO(指的是input、output即输入输出，好比网络、文件操做等)操做时，像访问网络，就自动切换到其余的greenlet，等到IO操做完成，再在适当的时候切换回来继续执行。

因为IO操做很是耗时，常常使程序处于等待状态，有了gevent为咱们自动切换协程，就保证总有greenlet在运行，而不是等待IO。

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 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

gevent并发下载器

固然，实际代码里，咱们不会用gevent.sleep()去切换协程，而是在执行到IO操做时，gevent自动切换。代码以下：

 1 from gevent import monkey
 2 import gevent
 3 import urllib.request
 4 
 5 # 有IO操做时须要这一句
 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