Python协程你学会了吗？

在学习协程之前，你需要先知道协程是什么？协程又称为微线程，一个程序可以包含多个协程，可以对比与一个进程包含多个线程，因而下面我们来比较协程和线程。我们知道多个线程相对独立，有自己的上下文，切换受系统控制；而协程也相对独立，有自己的上下文，但是其切换由自己控制。　   协程是一个线程执行，两个子过程通过相互协作完成某个任务。协程和子程序调用很像，但协程是在子程序内部中断去执行别的子程序，适当时候返回接着执行，中断有别于函数调用。

好了，废话不多说，我们直接上实例，结合实战来搞懂这个不算特别容易理解的概念。之后，我们再由浅入深，直击协程的核心。

我们先看一个简单的爬虫例子：

import time

def crawl_page(url):
    print('crawling {}'.format(url))
    time.sleep(2)
    print('OK {}'.format(url))

a=['url1', 'url2', 'url3', 'url4']
start=time.time()
for url in a:
    crawl_page(url)
end=time.time()
print('use {}'.format(end-start))

###输出
crawling url1
OK url1
crawling url2
OK url2
crawling url3
OK url3
crawling url4
OK url4
use 8.007500886917114

　　  这是一个很简单的爬虫函数执行时，调取 crawl_page() 函数进行网络通信，经过2秒等待后收到结果，然后执行下一个。4个url抓取耗费了8s的时间。下面我们来看看协程的实现。

import asyncio

async def crawl_page(url):
    print('crawling {}'.format(url))
    await asyncio.sleep(2)
    print('OK {}'.format(url))

async def run(urls):
    for url in urls:
        await crawl_page(url)

start=time.time()
asyncio.run(run(['url1', 'url2', 'url3', 'url4']))
end=time.time()
print('use {}s'.format(end-start))

####输出
crawling url1
OK url1
crawling url2
OK url2
crawling url3
OK url3
crawling url4
OK url4
use 8.012088060379028s

　　

也许你会发现，怎么还是耗时8s，和顺序执行没任何区别啊，这什么玩意。你说对了，我们先带着这个疑问继续往下看。在讲解之前，我们先分析一下这个代码，首先来看 import asyncio（注意是在python3.7版本以上才可以哦），这个库包含了大部分我们实现协程所需的魔法工具。

async 修饰词声明异步函数，于是，这里的 crawl_page 和 run 都变成了异步函数。而调用异步函数，我们便可得到一个协程对象（coroutine object）。

我们再来说说协程的执行。这里我介绍一下常用的三种。

• 我们可以通过 await 来调用。await 执行的效果，和 Python 正常执行是一样的，也就是说程序会阻塞在这里，进入被调用的协程函数，执行完毕返回后再继续，而这也是 await 的字面意思。代码中 await asyncio.sleep(sleep_time) 会在这里休息若干秒，await crawl_page(url) 则会执行 crawl_page() 函数。

• 我们可以通过 asyncio.create_task() 来创建任务，这个我们下节课会详细讲一下，你先简单知道即可。

• 我们需要 asyncio.run 来触发运行。asyncio.run 这个函数是 Python 3.7 之后才有的特性，可以让 Python 的协程接口变得非常简单，你不用去理会事件循环怎么定义和怎么使用的问题（我们会在下面讲）。

到此，我们应该可以看懂上面的代码了吧，不懂也没关系，我们继续分析。还记得上面await 是同步调用，因此， crawl_page(url) 在当前的调用结束之前，是不会触发下一次调用的。于是，这个代码效果就和上面完全一样了，相当于我们用异步接口写了个同步代码。我们接下来就来真正写一个异步的代码。

import asyncio

async def crawl_page(url):
    print('crawling {}'.format(url))
    await asyncio.sleep(2)
    print('OK {}'.format(url))

async def run(urls):
    tasks = []
    for url in urls:
        tasks.append(asyncio.create_task(crawl_page(url)))

    for task in tasks:
        await task

start=time.time()
urls=['url1', 'url2', 'url3', 'url4']
asyncio.run(run(urls))
end=time.time()
print('use {}s'.format(end-start))

####输出#####
crawling url1
crawling url2
crawling url3
crawling url4
OK url1
OK url2
OK url3
OK url4
use 2.0025851726531982s

　　

你可以看到，我们有了协程对象后，便可以通过 asyncio.create_task 来创建任务。任务创建后很快就会被调度执行，这样，我们的代码也不会阻塞在任务这里。所以，我们要等所有任务都结束才行，用for task in tasks: await task 即可。

下面我们来深入分析一下协程的执行过程。

import asyncio

async def worker_1():
    print('worker_1 start')
    await asyncio.sleep(1)
    print('worker_1 done')

async def worker_2():
    print('worker_2 start')
    await asyncio.sleep(2)
    print('worker_2 done')

async def run():
    task1 = asyncio.create_task(worker_1())
    task2 = asyncio.create_task(worker_2())
    print('before await')
    await task1
    print('awaited worker_1')
    await task2
    print('awaited worker_2')

start=time.time()
asyncio.run(run())
end=time.time()
print('use {}s'.format(end-start))

#####结果#####
before await
worker_1 start
worker_2 start
worker_1 done
awaited worker_1
worker_2 done
awaited worker_2
use 2.001868963241577s

　　

让我们来执行分析一下。

1. asyncio.run(run())，程序进入 run() 函数，事件循环开启。

2. task1 和 task2 任务被创建，并进入事件循环等待运行；运行到 print，输出 'before await'；

3. await task1 执行，用户选择从当前的主任务中切出，事件调度器开始调度 worker_1；

4. worker_1 开始运行，运行 print 输出'worker_1 start'，然后运行到 await asyncio.sleep(1)， 从当前任务切出，事件调度器开始调度 worker_2；

5. worker_2 开始运行，运行 print 输出 'worker_2 start'，然后运行 await asyncio.sleep(2) 从当前任务切出；

6. 一秒钟后，worker_1 的 sleep 完成，事件调度器将控制权重新传给 task_1，输出 'worker_1 done'，task_1 完成任务，从事件循环中退出；

7. await task1 完成，事件调度器将控制器传给主任务，输出 'awaited worker_1'，然后在 await task2 处继续等待；

8. 两秒钟后，worker_2 的 sleep 完成，事件调度器将控制权重新传给 task_2，输出 'worker_2 done'，task_2 完成任务，从事件循环中退出；

9. 主任务输出 'awaited worker_2'，协程全任务结束，事件循环结束。

最后我们来总结一下今天的内容。

• 协程和多线程的区别，主要在于两点，一是协程为单线程；二是协程由用户决定，在哪些地方交出控制权，切换到下一个任务。

• 协程的写法更加简洁清晰，把 async、await 和 create_task 结合来用，对于中小级别的并发需求已经毫无压力。

欢迎大家留言和我交流。