1 引言
协程是近几年并发编程的一个热门话题，与Python多进程、多线程相比，协程在很多方面优势明显。本文从协程的定义和意义出发，结合asyncio模块详细讲述协程的使用。
2 协程的意义
2.1 什么是协程
协程，又称微线程，英文名为Coroutine。对于多线程，在执行一个个不同任务时，遇到阻塞（例如IO操作）时，操作系统会自动将CPU资源切换给另一个线程。但协程不同，协程是用户态的轻量级线程，更多的依靠用户切换。
2.2 协程的作用
与线程不同的是，协程需要用户自己进行手动切换——当某线程在执行任务中的函数A（协程A））时，可任意中断，手动切换到任务中的另一个函数B（协程B），然后在适当的时候在回到函数A（协程A）中继续执行，这样虽然繁琐，但也提供了更大的操作*度，同时协程A和协程B都属于同一线程，切换效率相比于线程或进程间的切换有极大地优势。另外，协程不需要多线程的锁机制，因为都属于同一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只需要判断状态就好了，所以执行效率比多线程高很多。
我们以爬虫为例子，说明协程的应用。启动一个爬虫程序一定属于一个进程，这是毋庸置疑的，但进程本身并不会执行任何操作，所有操作都是通过线程来完成，所以一个进程有一个主线程。一般爬虫的步骤包括发送request请求、写入文件等操作，而这些都是IO操作，当线程执行到这些操作时，要么等待这一操作完成要么切换到其他线程。如果使用了协程呢？如果协程遇到了此类IO操作，可以立即切换到其他操作，例如直接发送下一个request请求，甚至发送第二个、第三个请求……直至原来的协程中IO请求完成，那么回到原来的协程继续下一步操作。这就是协程的工作原理，充分利用线程的工作效率，也没有多线程切换的开销，所以在处理IO操作时协程非常高效。
简单总结一下协程的优缺点：
优点：
1）无需线程上下文切换的开销（还是单线程）；
2）无需原子操作的锁定和同步的开销；
3）方便切换控制流，简化编程模型；
4）高并发+高扩展+低成本：一个cpu支持上万的协程都没有问题，适合用于高并发处理。
缺点：
1）无法利用多核的资源，协程本身是个单线程，它不能同时将单个cpu的多核用上，协程需要和进程配合才能运用到多cpu上（协程是跑在线程上的）；
2）进行阻塞操作时会阻塞掉整个程序：如io；
现在，各位读者应该已经对协程的概念又说了解了，也感受到了协程的魅力了吧！那么下面该说说怎么使用协程了……
2.3 相关概念
在Python中， asyncio、tornado和gevent等模块都实现了协程的功能。本篇中主要介绍asyncio。
在介绍通过asyncio的使用协程之前，首先有必要先介绍一下asyncio中涉及的几个概念，要想掌握asyncio，这几个贯穿始终的概念必须好好理解：
1）event_loop事件循环：程序开启一个事件的循环，程序员会把一些函数（协程）注册到事件循环上。当满足事件发生的时候，调用相应的协程函数。
2）coroutine 协程：协程对象，指一个使用async关键字定义的函数，它的调用不会立即执行函数，而是会返回一个协程对象。协程对象需要注册到事件循环，由事件循环调用。
3）future 对象： 代表将来执行或没有执行的任务的结果。它和task上没有本质的区别
4）task 任务：一个协程对象就是一个原生可以挂起的函数，任务则是对协程进一步封装，其中包含任务的各种状态。Task 对象是 Future 的子类，它将coroutine和Future联系在一起，将 coroutine 封装成一个 Future 对象。
5）async/await 关键字：python3.5 用于定义协程的关键字，async定义一个协程，await用于挂起阻塞的异步调用接口，await就类似于说下面过程阻塞，暂时执行别的协程。await关键字添加了一个新的协程到循环里，而不需要明确地添加协程到这个事件循环里。
3 定义协程
定义协程比定义进程或者线程还要简单，你只需要在普通函数定义时在“def”关键字前面加上一个“asyncio”，即可把普通函数定义为一个协程：
async def firstCorouctine(path=‘a.txt’):
print(‘协程执行开始……’)
await asyncio.sleep(1)
print(‘协程执行结束……’)
如果单单看firstCorouctine()，我想大家都看得出这个函数的功能。有 “async”这个关键字在前面修饰之后，这个函数就变成了一个协程——这就是定义协程的方法。所以说，协程某种意义上就是一个函数。我们可以通过asyncio.iscoroutinefunction函数来查看某个函数到底是不是协程，如果是协程则返回True，否则返回False：
import asyncio
async def firstCorouctine():
print(‘协程执行开始……’)
await asyncio.sleep(1)
print(‘协程执行结束……’)
def fun(path):
print(‘这是一个普通函数’)
print(‘firstCorouctine是协程吗：{}’.format(asyncio.iscoroutinefunction(firstCorouctine)))
print(‘fun是协程吗：{}’.format(asyncio.iscoroutinefunction(fun)))
输出结果：
firstCorouctine是协程吗：True
fun是协程吗：False
怎么样，简单吧？不过我猜，你心里还是一团懵，甚至在想这有什么用呢？请继续往下看。
4 使用协程
4.1 单个协程
使用协程须得经过一下几个步骤：定义协程->（封装成task->）获取事件循环->将task放到事件循环中执行。定义好的协程并不能直接使用，需要将其包装成为了一个任务（task对象），然后放到事件循环中才能被执行。所谓task对象是Future类的一个子类，保存了协程运行后的状态，用于未来获取协程的结果。在上面的步骤中，之所以在封装task这一个步骤上加上括号，是因为我们也可以选择直接将协程放到事件循环中，事件循环会自动帮我们完成这一操作。
所以，从定义好一个协程，到执行一个协程就有不同的方法：
第一种，通过asyncio 提供的ensure_future()函数创建task，然后执行
import asyncio async def firstCorouctine(): # 定义协程 print(‘协程执行开始……’) await asyncio.sleep(1) print(‘协程执行结束……’) coroutine = firstCorouctine() # 将协程赋值给coroutine task = asyncio.ensure_future(coroutine) # 封装为task loop = asyncio.get_event_loop() # 获取事件循环 loop.run_until_complete(task) # 执行
第二种，直接通过事件循环的create_task方法创建task，然后执行：
import asyncio
async def firstCorouctine(): # 定义协程
print(‘协程执行开始……’)
await asyncio.sleep(1)
print(‘协程执行结束……’)
coroutine = firstCorouctine() # 将协程赋值给coroutine
loop = asyncio.get_event_loop() # 获取事件循环
task = loop.create_task(coroutine) # 封装为task
loop.run_until_complete(task) # 执行
第三种：直接将协程放到事件循环中执行。这种方法并不是说不用将协程封装为task，而是事件循环内部会自动帮我们完成这一步骤。
import asyncio async def firstCorouctine(): # 定义协程 print(‘协程执行开始……’) await asyncio.sleep(1) print(‘协程执行结束……’) coroutine = firstCorouctine() # 将协程赋值给coroutine loop = asyncio.get_event_loop() # 获取事件循环 loop.run_until_complete(coroutine) # 执行
当然，无论是上述哪一种方法，最终都需要通过run_until_complete方法去执行我们定义好的协程。run_until_complete 是一个阻塞（blocking）调用，直到协程运行结束，它才返回。这一点从函数名中就可以看得出来。
4.2 多协程并发
协程往往是多个一起应用在事件循环里的，将多个协程加入事件循环需要借助 asyncio.gather 函数或者asyncio.wait函数，两个函数功能极其相似，不同的是，gather接受的参数是多个协程，而wait接受的是一个协程列表。async.wait会返回两个值:done和pending，done为已完成的task，pending为超时未完成的task。而async.gather只返回已完成task。
使用waiter函数：
import asyncio
async def firstCorouctine(n): # 定义协程
print('协程{}开始执行……'.format(n))
await asyncio.sleep(1)
print('协程{}结束执行……'.format(n))
task_list = [
asyncio.ensure_future(firstCorouctine(1)),
asyncio.ensure_future(firstCorouctine(2)),
asyncio.ensure_future(firstCorouctine(3))
]
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(task_list)) # 使用wait函数
输出结果：
协程1开始执行……
协程2开始执行……
协程3开始执行……
协程1结束执行……
协程2结束执行……
协程3结束执行……
使用gather函数：
import asyncio
async def firstCorouctine(n): # 定义协程
print('协程{}开始执行……'.format(n))
await asyncio.sleep(1)
print('协程{}结束执行……'.format(n))
task1 = asyncio.ensure_future(firstCorouctine(1))
task2 = asyncio.ensure_future(firstCorouctine(2))
task3 = asyncio.ensure_future(firstCorouctine(3))
tasks = asyncio.gather(task1, task2, task3)#如果协程有返回值时，最好赋值给一个tasks，方便回取返回结果
loop = asyncio.get_event_loop()
loop.run_until_complete(tasks)
输出结果：
协程1开始执行……
协程2开始执行……
协程3开始执行……
协程1结束执行……
协程2结束执行……
协程3结束执行……
4.3 获取返回值
前面的章节中说到，协程本质上来说也是一种函数，既然是函数就可以返回值。那么，协程执行完后，怎么获取它的返回值呢？task是future实例化对象，它封装有一个result()方法，通过task调用result()方法，可以获取协程的返回值：
import asyncio
async def firstCorouctine(): # 定义协程
await asyncio.sleep(1)
return ‘1234567890’
coroutine = firstCorouctine() # 将协程赋值给coroutine
task = asyncio.ensure_future(coroutine) # 封装为task
loop = asyncio.get_event_loop() # 获取事件循环
loop.run_until_complete(task) # 执行
return_value = task.result() # 获取协程返回值
print(‘协程返回的值为：{}’.format(return_value))
输出结果：
协程返回的值为：1234567890
上面的例子是单个协程是获取返回值，如果多个协程呢？使用多个协程并发时，将多个task列表传入事件循环中执行，返回的task列表中的每一个task对象就包含了返回值：
import asyncio
async def firstCorouctine(n): # 定义协程
print('协程{}开始执行……'.format(n))
await asyncio.sleep(1)
print('协程{}结束执行……'.format(n))
return n
task_list = [
asyncio.ensure_future(firstCorouctine(1)),
asyncio.ensure_future(firstCorouctine(2)),
asyncio.ensure_future(firstCorouctine(3))
]
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(task_list))
for task in task_list:
print(task.result())
输出结果：
协程1开始执行……
协程2开始执行……
协程3开始执行……
协程1结束执行……
协程2结束执行……
协程3结束执行……
1
2
3
4.4 绑定回调函数
在实际应用中，协程执行结束之后并不意味这整个任务就完成了，还需要运行其他函数，且其他函数也会用到协程的返回值，这就涉及到回调函数。协程中设置回调函数时需要将future对象（也就是我们创建的task）传入函数中，不过这个传参是自动完成的，所以回调函数必须至少设置一个形参：
import asyncio
async def firstCorouctine(): # 定义协程
await asyncio.sleep(1)
return '1234567890'
def callBack(future): # 定义一个回调函数
print('我是回调函数，协程返回值为：{}'.format(future.result()))
coroutine = firstCorouctine()
task = asyncio.ensure_future(coroutine)
task.add_done_callback(callBack) # 绑定回调函数
loop = asyncio.get_event_loop()
loop.run_until_complete(task)
输出结果：
我是回调函数，协程返回值为：1234567890
如果还需要传入其他参数，就需要借助偏函数（functools.partial）来辅助使用了，这时候切记future对象是放在最后的：
import asyncio
import functools
async def firstCorouctine(): # 定义协程
await asyncio.sleep(1)
return ''
def callBack(value , future): # 定义一个回调函数
print('我是回调函数，你输入的第一个参数为：{}'.format(value))
print('我是回调函数，协程返回值为：{}'.format(future.result()))
coroutine = firstCorouctine()
task = asyncio.ensure_future(coroutine)
task.add_done_callback(functools.partial(callBack , 123)) # 绑定回调函数
loop = asyncio.get_event_loop()
loop.run_until_complete(task)
输出结果：
我是回调函数，你输入的第一个参数为：123
我是回调函数，协程返回值为：1234567890
4.5 协程的嵌套使用
事件循环执行协程时是通过run_until_complete方法，这个方法只接收一个协程或者future对象作为参数。在前面章节中，我们在介绍多协程并发操作时，用的是asyncio.wait函数和asyncio.gather函数，这两个函数本身也是一个协程，当接收多个协程作为参数时，实际上是在wait（或gather）协程里面执行了我们传入的多个协程，然后把结果返回。这就证明，协程是可以嵌套的。我们也可以通过wait和gather来写我们自己的嵌套协程。
使用wait函数嵌套：
import asyncio
async def innerCorouctine(n): # 嵌套在里层的协程
print('innerCorouctine-{}开始执行……'.format(n))
await asyncio.sleep(1)
print('innerCorouctine-{}结束执行……'.format(n))
return n
async def outerCorouctine():
print('outerCorouctine开始执行……')
coroutine1 = innerCorouctine(1)
coroutine2 = innerCorouctine(2)
coroutine3 = innerCorouctine(3)
tasks = [
asyncio.ensure_future(coroutine1),
asyncio.ensure_future(coroutine2),
asyncio.ensure_future(coroutine3)
]
dones, pendings = await asyncio.wait(tasks)
for task in dones:
print('协程返回值：{} '.format(task.result()))
print('outerCorouctine结束行……')
loop = asyncio.get_event_loop()
loop.run_until_complete(outerCorouctine())
输出结果：
outerCorouctine开始执行……
innerCorouctine-1开始执行……
innerCorouctine-2开始执行……
innerCorouctine-3开始执行……
innerCorouctine-1结束执行……
innerCorouctine-2结束执行……
innerCorouctine-3结束执行……
协程返回值：1
协程返回值：3
协程返回值：2
outerCorouctine结束行……
使用gather方法进行嵌套：
import asyncio
async def innerCorouctine(n): # 嵌套在里层的协程
print('innerCorouctine-{}开始执行……'.format(n))
await asyncio.sleep(1)
print('innerCorouctine-{}结束执行……'.format(n))
return n
async def outerCorouctine():
print('outerCorouctine开始执行……')
coroutine1 = innerCorouctine(1)
coroutine2 = innerCorouctine(2)
coroutine3 = innerCorouctine(3)
tasks = [
asyncio.ensure_future(coroutine1),
asyncio.ensure_future(coroutine2),
asyncio.ensure_future(coroutine3)
]
tasks = await asyncio.gather(*tasks)
for task in tasks:
print('协程返回值：{} '.format(task))
print('outerCorouctine结束行……')
loop = asyncio.get_event_loop()
loop.run_until_complete(outerCorouctine())
输出结果：
outerCorouctine开始执行……
innerCorouctine-1开始执行……
innerCorouctine-2开始执行……
innerCorouctine-3开始执行……
innerCorouctine-1结束执行……
innerCorouctine-2结束执行……
innerCorouctine-3结束执行……
协程返回值：1
协程返回值：2
协程返回值：3
outerCorouctine结束行……
当然，也还有第三种方法进行嵌套，那就是使用run_until_complete函数：
import asyncio
async def innerCorouctine(n): # 嵌套在里层的协程
print('innerCorouctine-{}开始执行……'.format(n))
await asyncio.sleep(1)
print('innerCorouctine-{}结束执行……'.format(n))
return n
async def outerCorouctine():
print('outerCorouctine开始执行……')
coroutine1 = innerCorouctine(1)
coroutine2 = innerCorouctine(2)
coroutine3 = innerCorouctine(3)
tasks = [
asyncio.ensure_future(coroutine1),
asyncio.ensure_future(coroutine2),
asyncio.ensure_future(coroutine3)
]
for task in asyncio.as_completed(tasks):#使用as_completed函数
result = await task
print('协程返回值: {}'.format(result))
loop = asyncio.get_event_loop()
loop.run_until_complete(outerCorouctine())
输出结果：
outerCorouctine开始执行……
innerCorouctine-1开始执行……
innerCorouctine-2开始执行……
innerCorouctine-3开始执行……
innerCorouctine-1结束执行……
innerCorouctine-2结束执行……
innerCorouctine-3结束执行……
协程返回值: 1
协程返回值: 2
协程返回值: 3
5 总结
本文介绍了协程概念、意义和单线程下协程基本使用方法，但对于多线程下如何使用协程并未涉及，后续再进行补充。
参考资料：