title: Python 协程与异步
copyright: true
top: 0
date: 2018-08-11 10:15:50
tags:
categories: Python进阶笔记
permalink:
password:
keywords: 协程
description: Python2.7中用代码实现协程，同时区分同步与异步，以及异步的表现形式，回调与协程。
像烟花也是过一生，像樱花也是过一生，只要亮过和盛开过不就好了吗？
同步异步概念
当提到同步与异步，大家不免会想到另一组词语：阻塞与非阻塞。通常，同时提到这个这几个词语一般实在讨论network io的时候，在《unix network programming》中有详尽的解释，网络中也有许多讲解生动的文章。
关于异步 同步的一些理解：
同步和异步的区别就在于是否等待IO执行的结果。好比你去麦当劳点餐，你说“来个汉堡”，服务员告诉你，对不起，汉堡要现做，需要等5分钟，于是你站在收银台前面等了5分钟，拿到汉堡再去逛商场，这是同步IO。
你说“来个汉堡”，服务员告诉你，汉堡需要等5分钟，你可以先去逛商场，等做好了，我们再通知你，这样你可以立刻去干别的事情（逛商场），这是异步IO。
老张爱喝茶，废话不说，煮开水。出场人物：老张，水壶两把（普通水壶，简称水壶；会响的水壶，简称响水壶）。1 老张把水壶放到火上，立等水开。（同步阻塞）老张觉得自己有点傻2 老张把水壶放到火上，去客厅看电视，时不时去厨房看看水开没有。（同步非阻塞）老张还是觉得自己有点傻，于是变高端了，买了把会响笛的那种水壶。水开之后，能大声发出嘀~~~~的噪音。3 老张把响水壶放到火上，立等水开。（异步阻塞）老张觉得这样傻等意义不大4 老张把响水壶放到火上，去客厅看电视，水壶响之前不再去看它了，响了再去拿壶。（异步非阻塞）老张觉得自己聪明了。所谓同步异步，只是对于水壶而言。普通水壶，同步；响水壶，异步。虽然都能干活，但响水壶可以在自己完工之后，提示老张水开了。这是普通水壶所不能及的。同步只能让调用者去轮询自己（情况2中），造成老张效率的低下。所谓阻塞非阻塞，仅仅对于老张而言。立等的老张，阻塞；看电视的老张，非阻塞。情况1和情况3中老张就是阻塞的，媳妇喊他都不知道。虽然3中响水壶是异步的，可对于立等的老张没有太大的意义。所以一般异步是配合非阻塞使用的，这样才能发挥异步的效用。
并发通常指有多个任务需要同时进行，并行则是同一时刻有多个任务执行。用多线程、多进程、协程来说，协程实现并发，多线程与多进程实现并行。
关于异步 同步堵塞的一些理解：
同步阻塞，就好比火车站过安检，需要你耗费几分钟时间，都检查完了再进站，每个人都要耽误几分钟。
同步非阻塞，我们假设火车站提供了一种服务名叫“反馈”，你交10块钱就可以加一个微信号，然后你把车票、身份证、行李一次性放到一个地方，同时人家还保存了一下你的美照（这一系列操作后面统称“打包”），这样你可以直接进站买点东西呀上个厕所呀（后面统称“闲逛”），再通过微信不断询问 我的票检查好了吗？ 查好了吗？ 直到那头回复你说“好了”，你到指定地点去把你刚才打的包取回（后面统称“取包”），结束。
异步阻塞，你交20块钱买了“反馈2.0”—检查完毕人家会主动发微信告诉你，不需要你在不断询问了，而你“打包”完毕，还在检票口傻等，直到人家说“好了”，你在“取包”。这其实没有任何意义，因为你还是在等待，真正有意义的是异步非阻塞。
异步非阻塞，你交20块钱买了“反馈2.0”，“打包”完毕，“闲逛”，直到人家说“好了”，然后你“取包”。这才是真正把你解放了，既不用等着，也不用不断询问。而本文的asyncio用的就是异步非阻塞的协程。
协程
优点
-
无需线程上下文切换的开销
-
无需原子操作锁定及同步的开销
-
方便切换控制流，简化编程模型
-
高并发+高扩展性+低成本：一个CPU支持上万的协程都不是问题。所以很适合用于高并发处理
缺点
-
无法利用多核资源：协程的本质是个单线程,它不能同时将 单个CPU 的多个核用上,协程需要和进程配合才能运行在多CPU上.当然我们日常所编写的绝大部分应用都没有这个必要，除非是cpu密集型应用。
-
进行阻塞（Blocking）操作（如IO时）会阻塞掉整个程序
协程 2.7
协程：单线程里面不断切换这个单线程中的微进程，即通过代码来实现让一个线程中的更小进程来回切换，相对于多线程多进程可以节省线程切换的时间。
代码实现
协程在Python中使用yield生成器实现，每次执行到yield位置代码停止，返回一个数据，随后在别的地方可以接手这个数据后，代码恢复继续执行
# -*- coding: utf-8 -*-
# @Time : 2018/6/23 0023 10:19
# @Author : Langzi
# @Blog : www.langzi.fun
# @File : 协程.py
# @Software: PyCharm
import sys
import time
reload(sys)
sys.setdefaultencoding('utf-8')
def fun_1():
while 1:
n = yield 'FUN_1 执行完毕,切换到FUN_2'
# 函数运行到yield会暂停函数执行，存储这个值。并且有next():调用这个值，与send():外部传入一个值
if not n:
return
time.sleep(1)
print 'FUN_1 函数开始执行'
def fun_2(t):
t.next()
while 1:
print '-'*20
print 'FUN_2 函数开始执行'
time.sleep(1)
ret = t.send('over')
print ret
t.close()
if __name__ == '__main__':
n = fun_1()
fun_2(n)
可以看到，没有使用多线程处理，依然在两个函数中不断切换循环。
总结一下：
1. 第一个生产者函数中，使用yield，后面的代码暂时不会执行
2. 第一个函数执行到yield后，程序执行第二个函数，首先接受参数t，调用yield的下一个值，t.next()
3. 然后第二个函数继续执行，执行完后给第一个函数发送一些数据，ret=t.send(None)，其中ret就是第一个函数中yield的值
4. 最后关闭，t.close()
5. 把第一个函数的运行结果（其实就是当执行到yield的值）传递给第二个函数，第二个函数继续执行，然后把返回值继续传递给第一个函数。
协程 3.5
在Python3中新增asyncio库，在 3.5+ 版本中, asyncio 有两样语法非常重要, async, await. 弄懂了它们是如何协同工作的, 我们就完全能发挥出这个库的功能了。
基本用法
我们要时刻记住,asyncio 不是多进程, 也不是多线程, 单单是一个线程, 但是是在 Python 的功能间切换着执行. 切换的点用 await 来标记, 使用async关键词将其变成协程方法, 比如 async def function():。其中，async 定义一个协程，await 用来挂起阻塞方法的执行。
概念
- event_loop事件循环：程序开启一个无限的循环，当把一些函数注册到事件循环上时，满足事件发生条件即调用相应的函数。
- coroutine协程对象：指一个使用async关键字定义的函数，它的调用不会立即执行函数，而是会返回一个协程对象，协程对象需要注册到事件循环，由事件循环调用。
- task任务：一个协程对象就是一个原生可以挂起的函数，任务则是对协程进一步封装，其中包含任务的各种状态。
- future：代表将来执行或没有执行的任务的结果，它和task上没有本质的区别
- async/await关键字：python3.5用于定义协程的关键字，async定义一个协程，await用于挂起阻塞的异步调用接口。
代码演示
先看看不是异步的
# 不是异步的
import time
def job(t):
print('Start job ', t)
time.sleep(t) # wait for "t" seconds
print('Job ', t, ' takes ', t, ' s')
def main():
[job(t) for t in range(1, 3)]
t1 = time.time()
main()
print("NO async total time : ", time.time() - t1)
"""
Start job 1
Job 1 takes 1 s
Start job 2
Job 2 takes 2 s
NO async total time : 3.008603096008301
从上面可以看出, 我们的 job 是按顺序执行的, 必须执行完 job 1 才能开始执行 job 2, 而且 job 1 需要1秒的执行时间, 而 job 2 需要2秒. 所以总时间是 3 秒多. 而如果我们使用 asyncio 的形式, job 1 在等待 time.sleep(t) 结束的时候, 比如是等待一个网页的下载成功, 在这个地方是可以切换给 job 2, 让它开始执行.
然后是异步的
import asyncio
async def job(t): # async 形式的功能
print('Start job ', t)
await asyncio.sleep(t) # 等待 "t" 秒, 期间切换其他任务
print('Job ', t, ' takes ', t, ' s')
async def main(loop): # async 形式的功能
tasks = [
loop.create_task(job(t)) for t in range(1, 3)
] # 创建任务, 但是不执行
await asyncio.wait(tasks) # 执行并等待所有任务完成
t1 = time.time()
loop = asyncio.get_event_loop() # 建立 loop
loop.run_until_complete(main(loop)) # 执行 loop，并且等待所有任务结束
loop.close() # 关闭 loop
print("Async total time : ", time.time() - t1)
"""
Start job 1
Start job 2
Job 1 takes 1 s
Job 2 takes 2 s
Async total time : 2.001495838165283
"""
从结果可以看出, 我们没有等待 job 1 的结束才开始 job 2, 而是 job 1 触发了 await 的时候就切换到了 job 2 了. 这时, job 1 和 job 2 同时在等待 await asyncio.sleep(t), 所以最终的程序完成时间, 取决于等待最长的 t, 也就是 2秒. 这和上面用普通形式的代码相比(3秒), 的确快了很多.由于协程对象不能直接运行，在注册事件循环的时候，其实是run_until_complete方法将协程包装成为了一个任务（task）对象。所谓task对象是Future类的子类，保存了协程运行后的状态，用于未来获取协程的结果。
简单的例子：
import asyncio
import requests
async def scan(url):
r = requests.get(url).status_code
return r
task = asyncio.ensure_future(scan('http://www.langzi.fun'))
loop = asyncio.get_event_loop()
loop.run_until_complete(task)
print(task.result())
调用协程有好几种方法，这里就只看我这种即可，主要是后面三行。把任务赋值给task，然后loop为申请调度（这么理解），然后执行。因为requests这个库是同步堵塞的，所以没办法变成异步执行，这个时候学学aiohttp，一个唯一有可能在异步中取代requests的库。
绑定回调
就是让第一个函数执行后，执行的结果传递给第二个函数继续执行
例子：
import asyncio
import requests
async def request():
url = 'https://www.baidu.com'
status = requests.get(url)
return status
def callback(task):
print('Status:', task.result())
coroutine = request()
task = asyncio.ensure_future(coroutine)
task.add_done_callback(callback)
print('Task:', task)
loop = asyncio.get_event_loop()
loop.run_until_complete(task)
print('Task:', task)
在这里我们定义了一个 request() 方法，请求了百度，返回状态码，但是这个方法里面我们没有任何 print() 语句。随后我们定义了一个 callback() 方法，这个方法接收一个参数，是 task 对象，然后调用 print() 方法打印了 task 对象的结果。这样我们就定义好了一个 coroutine 对象和一个回调方法，我们现在希望的效果是，当 coroutine 对象执行完毕之后，就去执行声明的 callback() 方法。
那么它们二者怎样关联起来呢？很简单，只需要调用 add_done_callback() 方法即可，我们将 callback() 方法传递给了封装好的 task 对象，这样当 task 执行完毕之后就可以调用 callback() 方法了，同
最低0.47元/天 解锁文章
450
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
