​1. 初探
在了解异步协程之前，我们首先得了解一些基础概念，如阻塞和非阻塞、同步和异步、多进程和协程。

1.1 阻塞
阻塞状态指程序未得到所需计算资源时被挂起的状态。程序在等待某个操作完成期间，自身无法继续处理其他的事情，则称该程序在该操作上是阻塞的。

常见的阻塞形式有：

网络 I/O 阻塞

磁盘 I/O 阻塞

用户输入阻塞等。

阻塞是无处不在的，包括 CPU 切换上下文时，所有的进程都无法真正处理事情，它们也会被阻塞。如果是多核 CPU 则正在执行上下文切换操作的核不可被利用。

1.2 非阻塞
程序在等待某操作过程中，自身不被阻塞，可以继续处理其他的事情，则称该程序在该操作上是非阻塞的。

非阻塞并不是在任何程序级别、任何情况下都可以存在的。仅当程序封装的级别可以囊括独立的子程序单元时，它才可能存在非阻塞状态。

非阻塞的存在是因为阻塞存在，正因为某个操作阻塞导致的耗时与效率低下，我们才要把它变成非阻塞的。

1.3 同步
不同程序单元为了完成某个任务，在执行过程中需靠某种通信方式以协调一致，我们称这些程序单元是同步执行的。

例如购物系统中更新商品库存，需要用“行锁”作为通信信号，让不同的更新请求强制排队顺序执行，那更新库存的操作是同步的。

简言之，同步意味着有序。

1.4 异步
为完成某个任务，不同程序单元之间过程中无需通信协调，也能完成任务的方式，不相关的程序单元之间可以是异步的。

例如，爬虫下载网页。调度程序调用下载程序后，即可调度其他任务，而无需与该下载任务保持通信以协调行为。不同网页的下载、保存等操作都是无关的，也无需相互通知协调。这些异步操作的完成时刻并不确定。

简言之，异步意味着无序。

1.5 多进程
多进程就是利用 CPU 的多核优势，在同一时间并行地执行多个任务，可以大大提高执行效率。

1.6 协程
协程，英文叫作 Coroutine，又称微线程、纤程，协程是一种用户态的轻量级线程。

协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。因此协程能保留上一次调用时的状态，即所有局部状态的一个特定组合，每次过程重入时，就相当于进入上一次调用的状态。

协程本质上是个单进程，协程相对于多进程来说，无需线程上下文切换的开销，无需原子操作锁定及同步的开销，编程模型也非常简单。

我们可以使用协程来实现异步操作，比如在网络爬虫场景下，我们发出一个请求之后，需要等待一定的时间才能得到响应，但其实在这个等待过程中，程序可以干许多其他的事情，等到响应得到之后才切换回来继续处理，这样可以充分利用 CPU 和其他资源，这就是协程的优势。

1.7 协程相对于多线程的优点
多线程编程是比较困难的， 因为调度程序任何时候都能中断线程， 必须记住保留锁， 去保护程序中重要部分， 防止多线程在执行的过程中断。

而协程默认会做好全方位保护， 以防止中断。我们必须显示产出才能让程序的余下部分运行。对协程来说， 无需保留锁， 而在多个线程之间同步操作， 协程自身就会同步， 因为在任意时刻， 只有一个协程运行。总结下大概下面几点：

无需系统内核的上下文切换，减小开销；

无需原子操作锁定及同步的开销，不用担心资源共享的问题；

单线程即可实现高并发，单核 CPU 即便支持上万的协程都不是问题，所以很适合用于高并发处理，尤其是在应用在网络爬虫中。

2. 协程用法
接下来，我们来了解下协程的实现，从 Python 3.4 开始，Python 中加入了协程的概念，但这个版本的协程还是以生成器对象为基础的，在 Python 3.5 则增加了 async/await，使得协程的实现更加方便。

Python 中使用协程最常用的库莫过于 asyncio，所以本文会以 asyncio 为基础来介绍协程的使用。

首先我们需要了解下面几个概念。

event_loop：事件循环，相当于一个无限循环，我们可以把一些函数注册到这个事件循环上，当满足条件发生的时候，就会调用对应的处理方法。

coroutine：中文翻译叫协程，在 Python 中常指代为协程对象类型，我们可以将协程对象注册到事件循环中，它会被事件循环调用。我们可以使用 async 关键字来定义一个方法，这个方法在调用时不会立即被执行，而是返回一个协程对象。

task：任务，它是对协程对象的进一步封装，包含了任务的各个状态。

future：代表将来执行或没有执行的任务的结果，实际上和 task 没有本质区别。

另外我们还需要了解 async/await 关键字，它是从 Python 3.5 才出现的，专门用于定义协程。其中，async 定义一个协程，await 用来挂起阻塞方法的执行。

2.1 定义协程
协程就是一个函数，只是它满足以下几个特征：

依赖 I/O 操作（有 I/O 依赖的操作）

可以在进行 I/O 操作时暂停

无法直接运行

它的作用就是对有大量 I/O 操作的程序进行加速。

Python 协程属于可等待对象，因此可以在其他协程中被等待。

什么叫可等待对象？——await，如果前面被标记 await 就表明他是个协程，我们需要等待它返回一个数据。

# 代码示例 一
import asyncio
async def net():
  return 11
async def main():
  # net() # error
  await net() # right
asyncio.run(main())
​
import asyncio
async def net():
  return 11
async def main():
  # net() # error
  return await net() # right
print(asyncio.run(main()))

举个例子，我从网络上下载某个数据文件下载到我的本地电脑上，这很显然是一个 I/O 操作。比方这个文件较大（2GB），可能需要耗时 30min 才能下载成功。而在这 30min 里面，它会卡在 await 后面。这个 await 标记了协程，那就意味着它可以被暂停，那既然该任务可以被暂停，我们就把它分离出去。我这个线程继续执行其它任务，它这个 30min 分出去慢慢的传输，我这个程序再运行其他操作。

上面的代码，Python 3.6 会给你报错。报错信息如下：

Traceback (most recent call last):
  File "C:/Code/pycharm_daima/爬虫大师班/14-异步编程/test.py", line 26, in <module>
    asyncio.run(main())
AttributeError: module 'asyncio' has no attribute 'run

为什么会出现这样的报错呢？

因为从 Python 3.7+ 之后 Python 已经完全支持异步了，Python 3.6 之前只是支持部分异步，许多的方法是非常冗长的。

一个异步函数调用另一个异步函数：

import asyncio
async def net():
  return 11
async def main():
  # net() # error
  await net() # right
asyncio.run(main())

tips:

异步主要做得是 I/O 类型，CPU 密集型就不需要使用异步。

一个异步调用另一个异步函数，不能直接被调用，必须添加 await

我们使用代码验证一下，不加 await 调用试一试：

import asyncio
​
async def net():
  return 11
async def main():
  net() # error
asyncio.run(main())

输出结果：

C:/Code/pycharm_daima/爬虫大师班/14-异步编程/test.py:31: RuntimeWarning: coroutine 'net' was never awaited
  net() # error
RuntimeWarning: Enable tracemalloc to get the object allocation traceback

我们添加上 await 即可正常运行：

import asynci
​
async def net():
  return 11
async def main():
  # net() # error
  await net() # right
asyncio.run(main())

运行结果：

C:\Users\clela\AppData\Local\Programs\Python\Python37\python.exe C:/Code/pycharm_daima/异步编程/test.py
​
Process finished with exit code 0

运行成功并没有报错，接下来我们要输出得到的结果该怎么编写代码呢？直接赋值即可：

import asyncio
​
async def net():
  return 11
async def main():
  # net() # error
  a = await net() # right
  print(a)
asyncio.run(main())

Ps：async 标记异步，await 标记等待。

如果我们不想使用 await 来运行异步函数，那这个时候我们就可以按如下方法来运行代码：

import asyncio
​
async def net():
  return 11
​
async def main():
  task = asyncio.create_task(net())
  await task # right
  
asyncio.run(main())

首先我们来定义一个协程，体验一下它和普通进程在实现上的不同之处，代码如下：

# 代码示例二
import asyncio
async def execute(x):
  print('Number:', x)
  
coroutine = execute(1)
print('Coroutine:', coroutine)
print('After calling execute')
​
loop = asyncio.get_event_loop()
loop.run_until_complete(coroutine)
print('After calling loop')

代码示例二中，我们首先引入了 asyncio这个包࿰