如果把进程比作从A处到B处去这件事，那么线程就是可供选择的多条道路，协程就是道路上特殊路段（类似限速，一整条道路都是特殊路段的话，就是全部由协程实现）
例图如下：

1. 什么是协程（Coroutines）

在了解异步之前，先大致了解一下什么是协程。
网上的讲法有各种：

• 协程是一种比线程更加轻量级的存在
• 协程是一种用户级的轻量级线程
• 协程，又称微线程

大体看过之后就感觉，我好像懂了，有好像没懂，个人感觉有点晕乎乎的，没太明白。（PS:可能是我个人智商没够不能快速领悟的原因）
个人理解（PS：不涉及其本质来源、底层实现、仅仅就着这个异步爬虫来说）：协程就像一条带应急车道的高速公路（具体作用就是让任务有了暂停切换功能）
线程：把需要执行的任务比作汽车，线程就像一条单行且只有一条道的高速公路，只有等前一辆车到达终点后面的车才能出发，如果其中一辆出了事情停在了路上，那么这俩车后面的车就只能原地等待直到它恢复并到达终点才能继续上路。
协程：把需要执行的任务比作汽车，协程就像一条带应急车道的高速公路，如果汽车在中途出了问题就可以直接到一边的应急车道停下处理问题，下一辆车可以直接上路，简单来说就是可以通过程序控制哪辆车行驶，哪辆车在应急车道休息。

2.同步跟异步

同步跟异步是两个相对的概念：
同步：意味着有序
异步：意味着无序
小故事模拟事件：
小明在家需要完成如下事情：

1. 电饭锅煮饭大约30分钟
2. 洗衣机洗衣服大约40分钟
3. 写作业大约50分钟

在同步情况下：小明需要电饭锅处等待30分钟、洗衣机处等待40分钟、写作业50分钟，总计花费时间120分钟。
在异步情况下：小明需要电饭锅处理并启动花费10分钟、洗衣机处理并启动花费10分钟，写作业花费50分钟，总计花费时间70分钟。
即同步必须一件事情结束之后再进行下一件事，异步是可以在一件事情没结束就去处理另外一件事情了。
注意：此处异步比同步耗时更短是有前提条件的！要是I/O阻塞才可以（说人话：类似电饭锅煮饭，电饭锅可以自行完成这种的）

3、asyncio应用场景

• 在程序在执行 IO 密集型任务的时候，程序会因为等待 IO 而阻塞。
• 协程遇到io操作而阻塞时，立即切换到别的任务，如果操作完成则进行回调返回执行结果

4、asyncio的一些关键字的说明

• event_loop 事件循环：程序开启一个无限循环，把一些函数注册到事件循环上，当满足事件发生的时候，调用相应的协程函数
• coroutine协程：协程对象，指一个使用async关键字定义的函数，它的调用不会立即执行函数，而是会返回一个协程对象。协程对象需要注册到事件循环，由事件循环调用。
• task 任务：一个协程对象就是一个原生可以挂起的函数，任务则是对协程进一步封装，其中包含了任务的各种状态
• future: 代表将来执行或没有执行的任务的结果。它和task上没有本质上的区别
• async/await 关键字：python3.5用于定义协程的关键字，async定义一个协程，await用于挂起阻塞的异步调用接口。

5. asyncio基本使用

5.1、定义协程并创建tasks

• 在上面带中我们通过async关键字定义一个协程（coroutine）,当然协程不能直接运行，需要将协程加入到事件循环loop中
• asyncio.get_event_loop：创建一个事件循环，然后使用run_until_complete将协程注册到事件循环，并启动事件循环
• 协程对象不能直接运行，在注册事件循环的时候，其实是run_until_complete方法将协程包装成为了一个任务（task）对象.
• task对象是Future类的子类，保存了协程运行后的状态，用于未来获取协程的结果
  定义一个协程并创建tasks:

import asyncio
import time

# 我们通过async关键字定义一个协程,当然协程不能直接运行，需要将协程加入到事件循环loop中
async def do_some_work(x):
    print("waiting:", x)

start = time.time()

coroutine = do_some_work(2)
loop = asyncio.get_event_loop()        # asyncio.get_event_loop：创建一个事件循环
# 通过loop.create_task(coroutine)创建task,同样的可以通过 asyncio.ensure_future(coroutine)创建task
task = loop.create_task(coroutine)     # 创建任务, 不立即执行
loop.run_until_complete(task)         # 使用run_until_complete将协程注册到事件循环，并启动事件循环
print("Time:",time.time() - start)

5.2、绑定回调

绑定回调，在task执行完成的时候可以获取执行的结果，回调的最后一个参数是future对象，通过该对象可以获取协程返回值。
asyncio绑定回调:

import asyncio
import time

# 我们通过async关键字定义一个协程,当然协程不能直接运行，需要将协程加入到事件循环loop中
async def do_some_work(x):
    print("waiting:", x)
    return "Done after {}s".format(x)

def callback(future):
    print("callback:",future.result())

start = time.time()

coroutine = do_some_work(2)
loop = asyncio.get_event_loop()        # asyncio.get_event_loop：创建一个事件循环
# 通过loop.create_task(coroutine)创建task,同样的可以通过 asyncio.ensure_future(coroutine)创建task
task = loop.create_task(coroutine)     # 创建任务, 不立即执行
# task = asyncio.ensure_future(coroutine)
task.add_done_callback(callback)
# 绑定回调，在task执行完成的时候可以获取执行的结果
loop.run_until_complete(task)         # 使用run_until_complete将协程注册到事件循环，并启动事件循环
print("Time:",time.time() - start)

''' 运行结果
waiting: 2
callback: Done after 2s
Time: 0.0010030269622802734

5.3、阻塞和await

• 使用async可以定义协程对象，使用await可以针对耗时的操作进行挂起，就像生成器里的yield一样，函数让出控制权。
• 协程遇到await，事件循环将会挂起该协程，执行别的协程，直到其他的协程也挂起或者执行完毕，再进行下一个协程的执行
• 耗时的操作一般是一些IO操作，例如网络请求，文件读取等。
• 我们使用asyncio.sleep函数来模拟IO操作。协程的目的也是让这些IO操作异步化。
  普通串行花费7秒:

# 普通串行花费7秒
import time
def do_some_work(t):
    time.sleep(t)
    print('用了%s秒' % t)

start = time.time()
coroutine1 = do_some_work(1)
coroutine2 = do_some_work(2)
coroutine3 = do_some_work(4)
print(time.time()-start)
'''
用了1秒
用了2秒
用了4秒
7.002151012420654
'''

使用协程并发执行只花费4秒:

# 使用协程并发执行只花费4秒
import asyncio
import time

async def do_some_work(x):
    print("Waiting:",x)
    await asyncio.sleep(x)
    return "Done after {}s".format(x)

start = time.time()

coroutine1 = do_some_work(1)
coroutine2 = do_some_work(2)
coroutine3 = do_some_work(4)

tasks = [
    asyncio.ensure_future(coroutine1),
    asyncio.ensure_future(coroutine2),
    asyncio.ensure_future(coroutine3)
]

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

for task in tasks:
    print("Task ret:",task.result())

print("Time:",time.time() - start)
'''
Waiting: 1
Waiting: 2
Waiting: 4
Task ret: Done after 1s
Task ret: Done after 2s
Task ret: Done after 4s
Time: 4.0038135051727295
'''

5.4、协程嵌套

• 使用async可以定义协程，协程用于耗时的io操作，我们也可以封装更多的io操作过程
• 这样就实现了嵌套的协程，即一个协程中await了另外一个协程，如此连接起来。
  1）协程嵌套写法
  协程嵌套 普通写法:

# 1. 使用async可以定义协程，协程用于耗时的io操作，我们也可以封装更多的io操作过程
# 2. 这样就实现了嵌套的协程，即一个协程中await了另外一个协程，如此连接起来。import asyncio
import time
import asyncio

async def do_some_work(x):
    print("waiting:",x)
    await asyncio.sleep(x)
    return "Done after {}s".format(x)

async def main():
    coroutine1 = do_some_work(1)
    coroutine2 = do_some_work(2)
    coroutine3 = do_some_work(4)
    tasks = [
        asyncio.ensure_future(coroutine1),
        asyncio.ensure_future(coroutine2),
        asyncio.ensure_future(coroutine3)
    ]

    dones, pendings = await asyncio.wait(tasks)
    for task in dones:
        print("Task ret:", task.result())

    # results = await asyncio.gather(*tasks)
    # for result in results:
    #     print("Task ret:",result)


start = time.time()

loop = asyncio.get_event_loop()
loop.run_until_complete(main())
print("Time:", time.time() - start)
'''
waiting: 1
waiting: 2
waiting: 4
Task ret: Done after 1s
Task ret: Done after 2s
Task ret: Done after 4s
Time: 4.003407716751099
'''

2)协程嵌套 使用列表推导式简写:

import time
import asyncio

async def job(t):            # 使用 async 关键字将一个函数定义为协程
    await asyncio.sleep(t)   # 等待 t 秒, 期间切换执行其他任务
    print('用了%s秒' % t)

async def main(loop):           # 使用 async 关键字将一个函数定义为协程
    tasks = [loop.create_task(job(t)) for t in range(1,3)]  # 创建任务, 不立即执行
    await asyncio.wait(tasks)   # 执行并等待所有任务完成

start = time.time()
loop = asyncio.get_event_loop()      # 创建一个事件loop
loop.run_until_complete(main(loop))  # 将事件加入到事件循环loop
loop.close()                         # 关闭 loop

print(time.time()-start)
'''
用了1秒
用了2秒
2.0013420581817627
'''