python协程和异步io

没多少逻辑
228 阅读6分钟

同步和异步概念

同步

先执行第一个事务，如果遇到阻塞（time.sleep），会一直等待，直到第一个事务执行完毕， 才会执行第二事务。

同步执行代码程序如下：

import time
now = lambda: time.time()


def foo():
    # 制作阻塞场景
    time.sleep(1)


start = now()
for i in range(5):
    foo()
print("同步需要花费时间：", (now() - start))

异步

与同步是相对的，指执行第一个事务的时候，如果遇到阻塞，会直接执行第二个事务，不会等待,通过状态、通知、回调来调用处理结果

异步实现代码如下

import time
import asyncio

now = lambda: time.time()


async def foo():
   asyncio.sleep(1)

start = now()
loop = asyncio.get_event_loop()
for i in range(5):
   loop.run_until_complete(foo())
print("异步所花费的时间：", (now() - start))

在Python中有多种方式可以实现协程，例如：

  • greenlet，是一个第三方模块，用于实现协程代码（Gevent协程就是基于greenlet实现）
  • yield，生成器，借助生成器的特点也可以实现协程代码。
  • asyncio，在Python3.4中引入的模块用于编写协程代码。
  • async & awiat，在Python3.5中引入的两个关键字，结合asyncio模块可以更方便的编写协程代码。

greenlet

greentlet是一个第三方模块，需要提前安装 pip install greenlet才能使用

from greenlet import greenlet
def func1():
   print(1)        # 第1步：输出 1
   gr2.switch()    # 第3步：切换到 func2 函数
   print(2)        # 第6步：输出 2
   gr2.switch()    # 第7步：切换到 func2 函数，从上一次执行的位置继续向后执行
def func2():
   print(3)        # 第4步：输出 3
   gr1.switch()    # 第5步：切换到 func1 函数，从上一次执行的位置继续向后执行
   print(4)        # 第8步：输出 4
gr1 = greenlet(func1)
gr2 = greenlet(func2)
gr1.switch() # 第1步：去执行 func1 函数

注意：switch中也可以传递参数用于在切换执行时相互传递值。

yield

基于Python的生成器的yield和yield form关键字实现协程代码

def func1():
   yield 1
   yield from func2()
   yield 2
def func2():
   yield 3
   yield 4
f1 = func1()
for item in f1:
   print(item)

注意：yield form关键字是在Python3.3中引入的

asyncio

在Python3.4之前官方未提供协程的类库，一般大家都是使用greenlet等其他来实现。在Python3.4发布后官方正式支持协程，即：asyncio模块**。**

import asyncio
@asyncio.coroutine
def func1():
   print(1)
   yield from asyncio.sleep(2)  # 遇到IO耗时操作，自动化切换到tasks中的其他任务
   print(2)
@asyncio.coroutine
def func2():
   print(3)
   yield from asyncio.sleep(2) # 遇到IO耗时操作，自动化切换到tasks中的其他任务
   print(4)
tasks = [
   asyncio.ensure_future( func1() ),
   asyncio.ensure_future( func2() )
]
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

注意：基于asyncio模块实现的协程比之前的要更厉害，因为他的内部还集成了遇到IO耗时操作自动切花的功能。

定义协程

import asyncio


async def do_work(x):
   print('waiting:', x)

# 1、创建事件循环对象
loop = asyncio.get_event_loop()
# 2、将协程对象加入到事件循环中
loop.run_until_complete(do_work(3))

创建task

import asyncio


async def do_work(x):
    print('waiting:', x)

# 获取协程对象
coroutine = do_work(3)

# 1、创建事件循环对象
loop = asyncio.get_event_loop()

# 2、创建任务
task = loop.create_task(coroutine)
print(task)

# 3、将协程对象加入到事件循环中执行
loop.run_until_complete(task)
print(task)

绑定回调

绑定回调，在task执行完毕的时候可以获取执行的结果，回调的最后一个参数是future对象，通过该对象可以获取协程返回值。如果回调需要多个参数，可以通过偏导数导入, 此外,还可以利用task.result()来获取执行返回结果

import time
import asyncio
now = lambda: time.time()


async def do_work(x):
    print('waiting', x)
    return 'Done after {}s'.format(x)


##### 定义回调函数
def callback(future):
    # 利用future.result()来获取回调结果
    print('Callback:', future.result())


#####  获取协程对象
coroutine = do_work(3)
#####  创建事件循环
loop = asyncio.get_event_loop()
task = loop.create_task(coroutine)
#####  给任务添加绑定函数
task.add_done_callback(callback)
#####  运行任务
loop.run_until_complete(task)
#####  利用task.result()获取结果
 print(task.result())

#### 阻塞和await
>async & awit 关键字在Python3.5版本中正式引入，基于他编写的协程代码其实就是 上一示例 的加强版，让代码可以更加简便。
Python3.8之后 @asyncio.coroutine 装饰器就会被移除，推荐使用async & awit 关键字实现协程代码。

import asyncio async def func1(): print(1) await asyncio.sleep(2) print(2) async def func2(): print(3) await asyncio.sleep(2) print(4) tasks = [ asyncio.ensure_future(func1()), asyncio.ensure_future(func2()) ] loop = asyncio.get_event_loop() loop.run_until_complete(asyncio.wait(tasks))


>使用async可以定义协程对象，使用await可以针对耗时的操作进行挂起，就像生成器里的yield一样，函数让出控制权。协程遇到await，事件循环将会挂起该协程，执行别的协程,知道其他的协程也挂起或执行完毕，再进行下一个协程的执行。

耗时操作一般是一些IO操作，例如网络请求，文件读取等。我们使用asyncio.sleep函数来模拟IO操作。协程的目的也是为了让这些IO操作异步化。

import asyncio, time

async def do_work(x): print('waiting:', x) # 直接阻塞 await asyncio.sleep(x) return 'Done after {}s'.format(x) now = lambda: time.time() start = time.time()

创建协程对象

coroutine = do_work(3)

创建事件循环

loop = asyncio.get_event_loop()

创建任务

task = asyncio.ensure_future(coroutine)

执行任务

loop.run_until_complete(task) print('Task result:', task.result()) print('TIME:', now() - start)


![](https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/7/18/1736233040255cd1~tplv-t2oaga2asx-image.image)
### 协程的意义
- 计算型的操作，利用协程来回切换执行，没有任何意义，来回切换并保存状态 反倒会降低性能。
- IO型的操作，利用协程在IO等待时间就去切换执行其他任务，当IO操作结束后再自动回调，那么就会大大节省资源并提供性能，从而实现异步编程（不等待任务结束就可以去执行其他代码）

####  爬虫案例
例如：用代码实现下载 url_list 中的图片。

>方式一：同步编程实现

""" 下载图片使用第三方模块requests，请提前安装：pip3 install requests """ import requests def download_image(url): print("开始下载:",url) # 发送网络请求，下载图片 response = requests.get(url) print("下载完成") # 图片保存到本地文件 file_name = url.rsplit('_')[-1] with open(file_name, mode='wb') as file_object: file_object.write(response.content) if name == 'main': url_list = [ 'www3.autoimg.cn/newsdfs/g26…', 'www2.autoimg.cn/newsdfs/g30…', 'www3.autoimg.cn/newsdfs/g26…' ] for item in url_list: download_image(item)

>方式二：基于协程的异步编程实现

""" 下载图片使用第三方模块aiohttp，请提前安装：pip3 install aiohttp """ #!/usr/bin/env python

-- coding:utf-8 --

import aiohttp import asyncio async def fetch(session, url): print("发送请求：", url) async with session.get(url, verify_ssl=False) as response: content = await response.content.read() file_name = url.rsplit('_')[-1] with open(file_name, mode='wb') as file_object: file_object.write(content) async def main(): async with aiohttp.ClientSession() as session: url_list = [ 'www3.autoimg.cn/newsdfs/g26…', 'www2.autoimg.cn/newsdfs/g30…', 'www3.autoimg.cn/newsdfs/g26…' ] tasks = [asyncio.create_task(fetch(session, url)) for url in url_list] await asyncio.wait(tasks) if name == 'main': asyncio.run(main())

>上述两种的执行对比之后会发现，基于协程的异步编程 要比 同步编程的效率高了很多。因为：

- 同步编程，按照顺序逐一排队执行，如果图片下载时间为2分钟，那么全部执行完则需要6分钟。
- 异步编程，几乎同时发出了3个下载任务的请求（遇到IO请求自动切换去发送其他任务请求），如果图片下载时间为2分钟，那么全部执行完毕也大概需要2分钟左右就可以了。
avatar
文章
阅读
粉丝