异步基础概念
在了解异步协程之前，先得了解一些基础概念，如堵塞和非堵塞、同步和异步、多进程和协程。
阻塞
阻塞状态指程序未得到所需计算资源被挂起的状态。程序在等待某个操作完成期间，自身无法继续处理其它的事情，则称该程序在该操作上是阻塞的。
常见的阻塞形式有：网络I/O阻塞、磁盘I/O阻塞、用户输入阻塞等。阻塞是无处不在的，包括CPU切换上下文时，所有的进程都无法真正处理事情，它们也会被阻塞。如果是多核CPU则正在执行上下文切换操作的核不可被利用。
非阻塞
程序在等待某操作过程中，自身不被阻塞，可以继续处理其它的事情，则称该程序在该操作上是非阻塞的。
非阻塞并不是在任何程序级别、任何情况下都可以存在。仅当程序封装的级别可以包括独立的子程序单元时，它才可能存在非阻塞状态。
非堵塞的存在是因为堵塞存在，正因为某个操作阻塞导致的耗时与效率低下，我们才要把它变成非阻塞的。
同步
不同程序单元为了完成某个任务，在执行过程中需靠某种通信方式以协调一致，我们称这些程序单元是同步执行的。
例如购物系统中更新商品库存，需要用“行锁”作为通行信号，让不同的更新请求强制排队顺序执行。那更新库存的操作是同步的。
简言之，同步意味着有序。
异步
为完成某个任务，不同程序单元之间的过程中无需通信协调，也能完成任务的方式，不想关的程序单元可以是异步的。
例如，爬虫下载网页。调度程序调用下载程序后，即可调度起亚任务，而无需与该任务保持通信以协调行为，不同网页的下载、保存等操作都是无关的，也无需相互通知协调。这些异步操作的完成时刻并不确定。
简言之，异步意味者无序。
多进程
多进程就是利用CPU的多核优势，在同一时间并行地执行多个任务，可以大大提高执行效率。
协程
协程，英文叫做Coroutine，又称微线程、纤程，协程是一种用户态的轻量级线程。
协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其它地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。因此协程能保留上一次调用时的状态，即所有局部状态的一个特定组合，每次过程重入时，就相当于进入上一次调用的状态。
协程本质上是一个单进程，协程相对于多进程来说，无需线程上下文切换的开销，无需原子操作锁定及同步的开销，编程模型也非常简单。
可以使用协程来实现异步操作，比如在网络爬虫场景下，我们发出一个请求之后，需要等待一定的时间才能得到响应，但其实在这该等待过程中，程序可以干许多其它的事情，等到响应得到之后才切换回来继续处理，这样可以充分利用CPU和其它资源，这就是协程的优势。
协程的用法
接下来，了解下协程的实现，从Python3.4开始，Python中加入协程的概念，但这个版本的协程还是以生成器对象为基础的。在Python3.5则增加了async/await，使得协程的实现更加方便。
Python中使用协程最常用的库莫过与asyncio，所以本文以asyncio为基础来结束协程的使用
首先我们需要了解以下几个概念：
- event_loop：事件循环，相当于一个无限循环，可以把一些函数注册到这个事件循环上，当满足条件发生的时候，就会调用对应的处理方法。
- coroutine：中文翻译叫做协程，在Python中常指代为协程对象类型，可以将协程对象注册到时间循环中，他会被事件循环调用。我们可以使用async关键字来定义一个方法，这个方法在调用时不会立即执行，而是返回一个协程对象。
- task：任务，它是对协程对象的进一步封装。包含了任务的各个状态。
- future：代表将来执行或没有执行的任务的结果，实际上和task没有本质区别。
另，需要了解async/await关键字，它是从Python3.5才出现的，专门用于定义协程。其中，async定义一个协程，await用来挂起阻塞方法的执行。
定义协程
定义一个协程，体验一下它和普通进程在实现上的不同之处，
【示例一】如下：（此处重点说明一下，event_loop(事件循环)和coroutine)
import anyncio #声明引用asyncio
asyncio def execute(x):
print('Number:',x)
coroutine=execute(1)
print('Coroutine:',coroutine) #此处返回的是coroutine协程对象，
loop=asyncio.get_event_loop() #使用get_event_loop创建一个事件循环loop
loop.run_until_complete(coroutine) #调用loop对象run_until_complete方法将协程注册到事件循环loop中，然后启动。这样我们就可以看到execute方法打印输出的结果。
注：以上代码其实可以看出，async定义的方法就会变成一个无法直接执行的coroutine对象，必须将其注册到事件循环中才能执行。
【示例二】如下：(此处重点说明task，）
‘’‘
以下代码，提到task，它是对coroutine对象的进一步封装，
task里面比coroutine对象多了运行状态，
例如：
running，finished等
我们可以通过这些状态来获取协程对象的执行情况
’‘’
import asyncio
async def execute(x)
print('Number:',x)
return x
coroutine =execute(1) #返回coroutine协程对象
#-------------------定义task的方法一--------------------------
loop=asyncio.get_evet_loop() #定一个循环事件。
task =loop.create_task(coroutine) #这里是调用create_task方法将coroutine对象转化成task对象，
print('Task:',task) #这里打印输出，返回返现它是pending状态。
loop.run_until_complete(task) #我们将task对象，添加到事件循环中得到执行
print('Task:',task) #我们这次打印，发现他的状态变成finished，同时看到其result变成1，也就我们定义的execute方法返回的结果。
#------------------定义task的方法二--------------------------
‘’‘
此方法，定义task对象，可以直接通过asyncio的ensure_future方法
就可以不借助loop来定义，即使没有声明loop也可以提前定义好task对象
’‘’
task =asyncio.ensure_future(coroutine)
print('Task:',task)
loop =asyncio.get_event_loop() #定一个循环事件。
loop.run_until_complete(task)
print('Task:',task)当大家运行后，看到返回结果，发现其运行效果都是一样的。
绑定回调
另外我们可以为某个task绑定一个回调方法。
【示例】如下：
import asyncio
import requests
async def execute(url):
req = requests.get(url)
return req
def callback(response): #回调方法
print(response.result().status_code)
coroutine = execute('https://www.baidu.com')
task = asyncio.ensure_future(coroutine)
task.add_done_callback(callback)
loop = asyncio.get_event_loop()
loop.run_until_complete(task)上述代码，我们定义了一个request方法，请求一个百度，获取其状态码，这个方法里面我们没有任何print语句。
随后定义一个callback方法，这个方法接收一个参数，是response对象，这样我们就定义好一个coroutine对象和回调方法，我们现在希望的效果是，当coroutine对象执行完毕之后，就去执行声明的callback方法。
那么二者怎么关联起来？很简单只需要调用add_done_callback方法即可，我们将callback方法传递给封装好的task对象，这样当task执行完毕之后就可以调用callback方法了，同时task对象还会作为参数传递callback方法，调用task对象的result方法就可以获取返回结果。
注：我们也可以不使用回调方法，直接在task运行完毕后可以直接调用result方法获取结果
【示例】如下
import asyncio
import requests
async def execute(url):
req = requests.get(url)
return req
coroutine = execute('https://www.baidu.com')
task = asyncio.ensure_future(coroutine)
loop = asyncio.get_event_loop()
loop.run_until_complete(task)
print(task.result().status_code)以上示例，运行的结果是一样的。
多任务协程
上面的例子，我们只执行一次请求，如果我们想执行多次请求应该怎么办呢？我们可以定义一个task列表，然后使用asyncio的wait方法即可执行。
【示例】如下：
import asyncio
import requests
async def execute(url='https://www.baidu.com'):
req = requests.get(url)
return req
coroutine = execute
tasks = [asyncio.ensure_future(coroutine()) for _ in range(1,5)]
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
for i in tasks:
print('任务：',i.get_name(),'。状态：',i.result())这里我们用for循环创建了五个task，组成一个列表，然后把这个列表首先传递给了asyncio的wait()方法，然后在将其注册到时间循环中，就可以发起五个任务了。最后我们再将任务的运行结果输出就可以 了。
协程实现
上面的代码中，我们可以用一个网络请求作为示例，这就是一个耗时等待的操作，因为我们请求网页之后，需要等待页面响应并返回结果，耗时等待的操作一般都是IO操作，比如文件读取、网络请求等等。协程对于处理这种操作是有很大优势的，当遇到需要等待的情况的时候，程序可以暂时挂起，转而去执行其它操作，从而避免一直等待一个程序而耗费过多的时间，充分利用资源。
按照多任务协程上述代码里面，在执行过程中，其实是和正常请求并没有什么两样，依然是按照顺序执行的。
其实，要实现异步处理，我们先要有挂起的操作，当一个任务需要等待IO结果的时候，可以挂起当前任务，转而去执行其它任务，这样我们才能充分利用好资源。
要实现异步，接下来我们需要了解一下，await的用法，使用await可以将耗时等待的操作挂起，让出控制权，当协程执行的时候遇到await，时间循环就会将本协程挂起，转而去执行别的协程，直到其它的协程挂起或执行完毕。
#把//多任务协程下的代码里函数excute//修改程一下内容。
async def execute(url='https://www.baidu.com'):
print('Waiting for ',url)
req = await requests.get(url)
print('Get response from',url ,'response',req)
如果仅仅在requests前面加一个await，然而执行一下代码，会得到如下报错：
TypeError: object Response can't be used in 'await' expression
这次它遇到await方法确实挂起了，也等待了，但是最后却报这个错，这个错误的意思是requests返回的Response对象不能和await一起使用，这是为什么呢？因为根据官方文档说明，await后面格式必须如下格式之一：
- A native coroutine object returned from a native coroutine function，一个原生 coroutine 对象。
- A generator-based coroutine object returned from a function decorated with types.coroutine，一个由 types.coroutine 修饰的生成器，这个生成器可以返回 coroutine 对象。
- An object with an __await__ method returning an iterator，一个包含 __await__ 方法的对象返回的一个迭代器。
requests返回的Response不符合上面任一条件，因此就会报上面的错。
既然await后面可以跟一个coroutine对象，那么我用async把请求的方法改成coroutine对象不就可以了吗？所以改成如下的样子：
import asyncio, requests,time
start=time.time()
async def get(url):
req = requests.get(url)
return req.status_code
async def execute():
url = 'https://www.baidu.com'
print('Waiting for ', url)
response = await get(url)
print(response)
print('Get response from ', url, 'response', response)
tasks = [asyncio.ensure_future(execute()) for _ in range(10)]
loop =asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
end=time.time()
print('Cost time:',end-start)
这里我们将请求的页面的方法独立出来，并用async修饰，这样就得到一个coroutine对象。
//返回太多，需要的话自己运行看下。
从运行返回的内容，可以发现，还不是我们所需要的异步执行，也就是说，我们仅仅将涉及IO操作的代码封装到async修饰的方法里面是不可行的，我们必须要使用支持异步操作的请求方式才可以实现正在的异步，所以这里就需要aiohttp派上用场了。
使用aiohttp
aiohttp是一个支持异步请求的库，利用它和asyncio配合我们可以非常方便地实现异步请求操作。
安装如下：
pip install aiohttp
官方文档链接为：https://aiohttp.readthedocs.io/，它分为两部分，一部分是：Client，一部分是：Server，详细的内容可以参考官方文档。
下面将aiohttp用上，将代码改成如下：
import asyncio
import aiohttp
import time
start = time.time()
async def get(url):
session = aiohttp.ClientSession()
response = await session.get(url)
await response.text()
await session.close()
return response
async def request():
url = 'https://www.baidu.com'
print('Waiting for ', url)
response = await get(url)
print('Get response from ', url, 'response', response)
tasks = [asyncio.ensure_future(request()) for _ in range(10)]
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
end = time.time()
print('Cost time:', end - start)
在这里，我们将请求库有requests改成aiohttp，通过aiohttp的ClientSession类的get方法进行请求。
//上面的代码，大家自己运行，就能看到效果了。。