python异步asyncio模块的使用

本文首发于知乎
异步是继多线程、多进程以后第三种实现并发的方式，主要用于IO密集型任务的运行效率提高。python中的异步基于yield生成器，在讲解这部分原理以前，咱们先学会异步库asyncio的使用。

本文主要讲解asyncio模块的通用性问题，对一些函数细节的使用就简单略过。

本文分为以下部分

• 最简单的使用
• 另外一种常见的使用方式
• 一个问题
• 通常函数下的异步
• 理解异步、协程
• 单个线程的的异步爬虫

最简单的使用

import asyncio
async def myfun(i):
    print('start {}th'.format(i))
    await asyncio.sleep(1)
    print('finish {}th'.format(i))
loop = asyncio.get_event_loop()
myfun_list = (myfun(i) for i in range(10))
loop.run_until_complete(asyncio.gather(*myfun_list))
复制代码

这样运行，10次等待总共只等待了1秒。

上面代码一些约定俗成的用法记住就好，如

• 要想异步运行函数，须要在定义函数时前面加async
• 后三行都是记住就行，到时候把函数传入

另外一种常见的使用方式

上面是第一种常见的用法，下面是另一种

import asyncio
async def myfun(i):
    print('start {}th'.format(i))
    await asyncio.sleep(1)
    print('finish {}th'.format(i))
loop = asyncio.get_event_loop()
myfun_list = [asyncio.ensure_future(myfun(i)) for i in range(10)]
loop.run_until_complete(asyncio.wait(myfun_list))
复制代码

这种用法和上面一种的不一样在于后面调用的是asyncio.gather仍是asyncio.wait，当前当作彻底等价便可，因此平时使用用上面哪一种均可以。

上面是最常看到的两种使用方式，这里列出来保证读者在看其余文章时不会发蒙。

另外，两者实际上是有细微差异的

• gather更擅长于将函数聚合在一块儿
• wait更擅长筛选运行情况

细节能够参考这篇回答

一个问题

与以前学过的多线程、多进程相比，asyncio模块有一个很是大的不一样：传入的函数不是为所欲为

• 好比咱们把上面myfun函数中的sleep换成time.sleep(1)，运行时则不是异步的，而是同步，共等待了10秒
• 若是我换一个myfun，好比换成下面这个使用request抓取网页的函数

import asyncio
import requests
from bs4 import BeautifulSoup
async def get_title(a):
    url = 'https://movie.douban.com/top250?start={}&filter='.format(a*25)
    r = requests.get(url)
    soup = BeautifulSoup(r.content, 'html.parser')
    lis = soup.find('ol', class_='grid_view').find_all('li')
    for li in lis:
        title = li.find('span', class_="title").text
        print(title)
loop = asyncio.get_event_loop()
fun_list = (get_title(i) for i in range(10))
loop.run_until_complete(asyncio.gather(*fun_list))
复制代码

依然不会异步执行。

到这里咱们就会想，是否是异步只对它本身定义的sleep(await asyncio.sleep(1))才能触发异步？

通常函数下的异步

对于上述函数，asyncio库只能经过添加线程的方式实现异步，下面咱们实现time.sleep时的异步

import asyncio
import time
def myfun(i):
    print('start {}th'.format(i))
    time.sleep(1)
    print('finish {}th'.format(i))
async def main():
    loop = asyncio.get_event_loop()
    futures = (
        loop.run_in_executor(
            None,
            myfun, 
            i)
        for i in range(10)
        )
    for result in await asyncio.gather(*futures):
        pass
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
复制代码

上面run_in_executor其实开启了新的线程，再协调各个线程。调用过程比较复杂，只要当模板同样套用便可。

上面10次循环仍然不是一次性打印出来的，而是像分批次同样打印出来的。这是由于开启的线程不够多，若是想要实现一次打印，能够开启10个线程，代码以下

import concurrent.futures as cf # 多加一个模块
import asyncio
import time
def myfun(i):
    print('start {}th'.format(i))
    time.sleep(1)
    print('finish {}th'.format(i))
async def main():
    with cf.ThreadPoolExecutor(max_workers = 10) as executor: # 设置10个线程
        loop = asyncio.get_event_loop()
        futures = (
            loop.run_in_executor(
                executor, # 按照10个线程来执行
                myfun, 
                i)
            for i in range(10)
            )
        for result in await asyncio.gather(*futures):
            pass
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
复制代码

用这种方法实现requests异步爬虫代码以下

import concurrent.futures as cf
import asyncio
import requests
from bs4 import BeautifulSoup
def get_title(i):
    url = 'https://movie.douban.com/top250?start={}&filter='.format(i*25)
    r = requests.get(url)
    soup = BeautifulSoup(r.content, 'html.parser')
    lis = soup.find('ol', class_='grid_view').find_all('li')
    for li in lis:
        title = li.find('span', class_="title").text
        print(title)
async def main():
    with cf.ThreadPoolExecutor(max_workers = 10) as executor:
        loop = asyncio.get_event_loop()
        futures = (
            loop.run_in_executor(
                executor,
                get_title, 
                i)
            for i in range(10)
            )
        for result in await asyncio.gather(*futures):
            pass
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
复制代码

这部分参考这篇文章还有这个回答

这种开启多个线程的方式也算异步的一种，下面一节详细解释。

理解异步、协程

如今咱们讲了一些异步的使用，是时候解释一些概念了

• 首先，咱们要理清楚同步、异步、阻塞、非阻塞四个词语之间的联系
• 首先要明确，前二者后后二者并非一一对应的，它们不是在说同一件事情，可是很是相似，容易搞混
• 通常咱们说异步程序是非阻塞的，而同步既有阻塞也有非阻塞的
• 非阻塞是指一个任务没作完，没有必要停在那里等它结束就能够开始下一个任务，保证一直在干活没有等待；阻塞就相反是一件事彻底结束才开始另外一件事
• 在非阻塞的状况下，同步与异步都有可能，它们均可以在一个任务没结束就开启下一个任务。而两者的区别在于：（且称正在进行的程序为主程序）当第一个程序作完的时候（好比网络请求终于相应了），会自动通知主程序回来继续操做第一个任务的结果，这种是异步；而同步则是须要主程序不断去问第一个程序是否已经完成。
• 四个词的区别参考知乎回答
• （协程与多线程的区别）在非阻塞的状况下，多线程是同步的表明，协程是异步的表明。两者都开启了多个线程
• 多线程中，多个线程会竞争谁先运行，一个等待结束也不会去通知主程序，这样没有章法的随机运行会形成一些资源浪费
• 而协程中，多个线程（称为微线程）的调用和等待都是经过明确代码组织的。协程就像目标明确地执行一个又一个任务，而多线程则有一些彷徨迷茫的时间
• 两种异步
• 前面几节涉及到两种异步，一种是await只使用一个线程就能够实现任务切换，另外一种是开启了多个线程，经过线程调度实现异步
• 通常只用一个线程将任务在多个函数之间来回切换，是使用yield生成器实现的，例子能够看这篇文章最后生产消费者例子
• 多进程、多线程、异步擅长方向
• 异步和多线程都是在IO密集型任务上优点明显，由于它们的本质都是在尽可能避免IO等待时间形成的资源浪费。而多进程能够利用多核优点，适合CPU密集型任务
• 相比于多线程，异步更适合每次等待时间较长、须要等待的任务较多的程序。由于多线程毕竟要建立新的线程，线程过多使线程竞争现象更加明显，资源浪费也就更多。若是每一个任务等待时间过长，等待时间内势必开启了很是多任务，很是多线程，这时使用多线程就不是一个明智的决定。而异步则能够只开启一个线程在各个任务之间有条不紊进行，即能充分利用CPU资源，又不会影响程序运行效率

单个线程的的异步爬虫

上面咱们是经过开启多个线程来实现requests的异步，若是咱们想只用一个线程（用await），就要换一个网页请求函数。

事实上要想用await，必须是一个awaitable对象，这是不能使用requests的缘由。而转化成awaitable对象这样的事固然也不用咱们本身实现，如今有一个aiohttp模块能够将网页请求和asyncio模块完美对接。使用这个模块改写代码以下

import asyncio
import aiohttp
from bs4 import BeautifulSoup
async def get_title(i):
    url = 'https://movie.douban.com/top250?start={}&filter='.format(i*25)
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as resp:
            print(resp.status)
            text = await resp.text()
            print('start', i)
    soup = BeautifulSoup(text, 'html.parser')
    lis = soup.find('ol', class_='grid_view').find_all('li')
    for li in lis:
        title = li.find('span', class_="title").text
        print(title)
loop = asyncio.get_event_loop()
fun_list = (get_title(i) for i in range(10))
loop.run_until_complete(asyncio.gather(*fun_list))
复制代码

欢迎关注个人知乎专栏

专栏主页：python编程

专栏目录：目录

版本说明：软件及包版本说明