Python并发编程系列之协程
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 '1234567890' 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 总结
本文介绍了协程概念、意义和单线程下协程基本使用方法,但对于多线程下如何使用协程并未涉及,后续再进行补充。
参考资料:
![](https://files.cnblogs.com/files/chenhuabin/wechat.gif)
作者:奥辰
微信号:chb1137796095
Github:https://github.com/ChenHuabin321
欢迎加V交流,共同学习,共同进步!
本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文链接,否则保留追究法律责任的权利。