协程

  在python3.5以前,写成的实现都是通过生成器的yield from原理实现的, 这样实现的缺点是代码看起来会很乱,于是3.5版本之后python实现了原生的协程,并且引入了async和await两个关键字用于支持协程。于是在用async定义的协程与python的生成器彻底分开。

async def downloader(url):
return 'bobby' async def download_url(url):
html = await downloader(url)
return html
if __name__ == '__main__':
coro = download_url('http://www/imooc.com')
coro.send(None) 输出结果:
Traceback (most recent call last):
File "D:/MyCode/Cuiqingcai/Flask/test01.py", line , in <module>
coro.send(None)
StopIteration: bobby

可以看到结果中可以将downloader(url)的结果返回。需要注意的是在原生协程里面不能用next()来预激协程。

async def downloader(url):
return 'bobby' async def download_url(url):
html = await downloader(url)
return html
if __name__ == '__main__':
coro = download_url('http://www/imooc.com')
coro.next() 结果:
AttributeError: 'coroutine' object has no attribute 'next'
sys:1: RuntimeWarning: coroutine 'download_url' was never awaited

原生协程async代码中间是不能在使用yield生成器的,这样就为了更好的将原生协程与生成器严格区分开来。并且await只能和async语句搭配,不能和生成器搭配。因为要调用await需要调用对象实现__await__()这个魔法方法。所以在定义协程时候注意不要混用。但是理解的时候还是可以将原生的协程中 await可以对比生成器的yield from。

asyncio

高并发的核心模块,3.4之后引入,最具野性的模块,web服务器,爬虫都可以胜任。它是一个模块也可以看做一个框架。

协程编码模式的三个要点:

  1. 事件循环
  2. 回调(驱动生成器(协程))
  3. epoll(IO多路复用)

  asyncio的简单实用:

  这里需要注意的是:同步阻塞的接口不能使用在协程里面。因为协程是单线程的,只要有一个地方阻塞了,那么所有的协程都需要等待阻塞结束之后才可以向下运行,于是在协程函数中等待一定不能用time.sleep() 如果用time.sleep()就失去了协程的意义了(即程序运行的时间将会是每个协程数乘以time.sleep()的时间数。)同时用asyncio.sleep() 之前需要加上 await

import time
async def download_url(url):
print('start get %s' % url)
await asyncio.sleep(2)
print('get %s finished.' % url)
if __name__ == '__main__':
start_time = time.time()
loop = asyncio.get_event_loop()
loop.run_until_complete(download_url('https:www.baidu.com')) # 阻塞等事件完成之后再向下运行。相当于进程线程的join()方法,或者进线程池的wait()
print('一共用时:%s' % (time.time() - start_time)) start get https:www.baidu.com
get https:www.baidu.com finished.
一共用时:2.0011143684387207

  一次执行多个任务。(用时和一个任务一样!)下面任务如果换成time.sleep(2)则函数需要至少20秒才能执行完毕。

import asyncio
import time
async def download_url(url):
print('start get %s.' % url)
await asyncio.sleep(2)
print('get %s end' % url) if __name__ == '__main__':
start_time = time.time()
loop = asyncio.get_event_loop()
url_list = []
for i in range(10):
url_list.append('https:www.baidu.com.index{}'.format(i))
tasks = [download_url(url) for url in url_list]
loop.run_until_complete(asyncio.wait(tasks))
print('用时 %s' %(time.time() - start_time)) ...
...
用时 2.0031144618988037

  获取协程的返回值:

  可以用两种方式先得到一个future对象。然后将该future对象放入loop.run_until_complete()中。(该函数即可以接受future对象也可以接受协程对象)然后future对象跟进程池和线程池中的future对象的方法是一样的。于是可以用.result()方法的到函数的返回结果。

async def download_url(url):
# print('start get %s' % url)
await asyncio.sleep(2)
# print('get %s finished.' % url)
return 'frank is a good man.'
if __name__ == '__main__':
start_time = time.time()
loop = asyncio.get_event_loop()
# get_future = asyncio.ensure_future(download_url('https:www.baidu.com'))
get_task = loop.create_task(download_url('https:www.baidu.com'))
loop.run_until_complete(download_url(get_task))
print('一共用时:%s' % (time.time() - start_time))
print(get_task.result()) 一共用时:2.0021142959594727
frank is a good man.

  future完成之后的回调函数

  设置协程完成之后的回调函数:future对象的.add_done_callback(),注意在调用add_done_callback的时候会默认将future对象传递给回调函数,因此回调函数必须至少接受一个参数,同时add_done_callback必须在run_until_complete()前,(协程函数创建之后调用)因为如果在run_until_complete()之后的话,协程都应结束了。就不会起作用了。

async def download_url(url):
# print('start get %s' % url)
await asyncio.sleep(2)
# print('get %s finished.' % url)
return 'frank is a good man.' def send_emai(future):
print('网页下载完毕')
print(future.result()) if __name__ == '__main__':
start_time = time.time()
loop = asyncio.get_event_loop()
# get_future = asyncio.ensure_future(download_url('https:www.baidu.com'))
get_task = loop.create_task(download_url('https:www.baidu.com'))
get_task.add_done_callback(send_emai)
loop.run_until_complete(download_url(get_task)) print('一共用时:%s' % (time.time() - start_time))
print(get_task.result()) 网页下载完毕
frank is a good man.
一共用时:2.0021145343780518
frank is a good man.

问题来了。tasks.add_done_callback方法只能接受函数名,如果回调的方法也需要参数怎么办?这就需要用到偏函数from functools import partial (偏函数可以将函数包装成为另外一个函数)

import  asyncio
import time
from functools import partial
async def get_html(url):
print('start get url')
await asyncio.sleep(2)
return 'bobby' def callback_method(url, future):# 此处因为是future对象即(tasks)调用的,所以有一个默认的参数。同时要注意:回调函数的future只能放到最后,其它的函数实参放前面。
print('download ended %s' % url) if __name__ == '__main__':
start_time = time.time()
loop = asyncio.get_event_loop()
tasks = asyncio.ensure_future(get_html('http://www.baidu.com'))
# tasks = loop.create_task(get_html('http://www.baidu.com'))
tasks.add_done_callback(partial(callback_method, 'http://www.baidu.com')) # 参数为回调方法
loop.run_until_complete(tasks)
print(tasks.result()) start get url
download ended http://www.baidu.com
bobby

gather 与 wait的区别。都是可以等待程序运行之后往下运行。但是gather比wait更加高级一点

gather可以将任务分组:

import  asyncio
import time async def get_html(url):
print('start get %s' % url)
await asyncio.sleep(2)
print('end get %s' % url)
if __name__ == '__main__':
start_time = time.time()
loop = asyncio.get_event_loop()
group1 = [get_html('http://goup1.com') for i in range(2)]
group2 = [get_html('http://group2.com') for i in range(2)]
group1 = asyncio.gather(*group1)
group2 = asyncio.gather(*group2)
loop.run_until_complete(asyncio.gather(group1, group2))
# 上面三行代码也可以合一起loop.run_until_complete(asyncio.gather(*group1, *group2)) 注意此参数前面要加*
print(time.time()-start_time) start get http://goup1.com
start get http://group2.com
start get http://group2.com
start get http://goup1.com
end get http://goup1.com
end get http://group2.com
end get http://group2.com
end get http://goup1.com
2.0021145343780518

loop.run_forever()协程的任务完成之后不会停止,而是会一直运行。老师吐槽:python中间loop和future的关系有点乱,loop会被放到future中间同时future又可以放到loop中间,造成一个循环。

如何取消future(task)

async def get_html(sleep_time):
print('waiting')
await asyncio.sleep(sleep_time)
print('end after %s S' % sleep_time) if __name__ == '__main__':
task1 = get_html(2)
task2 = get_html(3)
task3 = get_html(4)
tasks = [task1, task2, task3]
loop = asyncio.get_event_loop()
try:
loop.run_until_complete(asyncio.wait(tasks))
except KeyboardInterrupt as e:
all_tasks = asyncio.Task.all_tasks()
for task in all_tasks:
print('cancel task')
print(task.cancel())# 打印是否取消 是返回Ture,否False
loop.stop()
loop.run_forever() # 注意此处一定要加上loop.run_forever()不然会报异常
finally:
loop.close()

waiting
waiting
waiting
cancel task
True
cancel task
True
cancel task
True
cancel task
True

将此代码进入cmd中运行,然后再中间按ctrl + C键,主动生成一个 KeyboardInterrupt 异常,然后异常被捕捉之后做出处理(即停止协程的运行)

协程的嵌套

import asyncio
async def compute(x, y):
print('Computer %s + %s...') % (x, y))
await asyncio.sleep(1)
return x + y async def print_sum(x, y):
result = await computer(x, y)
print("%s + %s = %s" % (x, y, result)) loop = asyncio.get_event_loop()
loop.run_until_complete(print_sum(1, 2))
loop.close()

代码分析图:

  1. loop首先会为print_sum()创建一个task
  2. event_loop()驱动task运行,使task进入(pending状态)
  3. task去执行print_sum
  4. print_sum中首先进入子协程的调度(await相当于yiel from)所以转向执行computer,print_sum自身暂停。
  5. compute中存在await 于是也被迫进入暂停状态,然后可以直接返回给task(await == yield from 而yield from可以在调度方与子生成器之间掠过委托方建立双向通道)
  6. task返回给event_loop()
  7. 等待1秒钟之后,task唤醒compute,compute继续执行下一行代码(即return x + y)完成之后compute就是一个done状态,同时抛出一个stopiterationError异常,此异常将激活print_sum()(委托方),并且将异常将被await(对应之前的yield from)捕捉并提取出return的值。
  8. print_sum()被激活之后执行print然后变成done状态,也会抛出一个stopiterationError异常,然后被task接受并处理了。

asyncio中的其他函数(以下三个为底层函数,多数条件下用得不多)

call_soon()

  在协程运行时候,可以传递一些函数去执行,注意是函数不是协程。

import asyncio
def callback(sleep_times):
print('sleep {} success'.format(sleep_times)) if __name__ =='__main__':
loop = asyncio.get_event_loop()
loop.call_soon(callback, ) #第一个参数为调用的函数名,第二个单数为被调用函数的参数
loop.run_forever() sleep success

  注意此处调动函数的运行需要用到loop.run_forever()而不是loop.run_until_complete()因为oop.call_soon()只是调用函数而不是loop注册的协程。

同时loop.run_forever()会导致程序一直在运行,不会自动结束。于是需要添加以下方法使程序关闭。

import asyncio
def callback(sleep_times):
print('sleep {} success'.format(sleep_times)) def stop_loop(loop):
loop.stop() if __name__ =='__main__':
loop = asyncio.get_event_loop()
loop.call_soon(callback, 2)
loop.call_soon(stop_loop, loop)
loop.run_forever()

call_later()

  功能,讲一个callback函数在一个指定的时候运行。

import asyncio
def callback(sleep_times):
print('sleep {} success'.format(sleep_times)) def stop_loop(loop):
loop.stop() if __name__ =='__main__':
loop = asyncio.get_event_loop()
loop.call_later(2, callback, 2) # 参数含义:第一个参数为延迟时间,延迟越少越先运行。
loop.call_later(1, callback, 1)
loop.call_later(3, callback, 3)
loop.call_soon(callback, 4)
loop.run_forever() sleep 4 success
sleep 1 success
sleep 2 success
sleep 3 success

同时存在call_soon()和call_later()时,call_soon()会在那个call_later()前面调用。

call_at()

  也是调用函数在指定时间内调用,但是它的指定时间,是指的loop内的时间,而不是自己传递的时间。可以用loop.time()来获取loop内时间。

import asyncio
def callback(sleep_times):
print('sleep {} success'.format(sleep_times)) if __name__ =='__main__':
loop = asyncio.get_event_loop()
now = loop.time()
loop.call_at(now+2, callback, 2) # 注意第一个参数是相对于loop系统时间而来的,不是自定义的几秒钟之后运行。
loop.call_at(now+1, callback, 1)
loop.call_at(now+3, callback, 3)
loop.call_soon(callback, 4)
loop.run_forever() sleep 4 success
sleep 1 success
sleep 2 success
sleep 3 success

协程中线程的实现

协程不提供阻塞的方式,但是有时候有些库,和有些接口只能提供阻塞方式连接。于是就可以在协程中继承阻塞io

Python 原生协程------asyncio的更多相关文章

  1. 运筹帷幄决胜千里,Python3.10原生协程asyncio工业级真实协程异步消费任务调度实践

    我们一直都相信这样一种说法:协程是比多线程更高效的一种并发工作方式,它完全由程序本身所控制,也就是在用户态执行,协程避免了像线程切换那样产生的上下文切换,在性能方面得到了很大的提升.毫无疑问,这是颠扑 ...

  2. 小议Python3的原生协程机制

    此文已由作者张耕源授权网易云社区发布. 欢迎访问网易云社区,了解更多网易技术产品运营经验. 在最近发布的 Python 3.5 版本中,官方正式引入了 async/await关键字.在 asyncio ...

  3. 物无定味适口者珍,Python3并发场景(CPU密集/IO密集)任务的并发方式的场景抉择(多线程threading/多进程multiprocessing/协程asyncio)

    原文转载自「刘悦的技术博客」https://v3u.cn/a_id_221 一般情况下,大家对Python原生的并发/并行工作方式:进程.线程和协程的关系与区别都能讲清楚.甚至具体的对象名称.内置方法 ...

  4. Python3的原生协程(Async/Await)和Tornado异步非阻塞

    原文转载自「刘悦的技术博客」https://v3u.cn/a_id_113 我们知道在程序在执行 IO 密集型任务的时候,程序会因为等待 IO 而阻塞,而协程作为一种用户态的轻量级线程,可以帮我们解决 ...

  5. 深入理解Python中协程的应用机制: 使用纯Python来实现一个操作系统吧!!

    本文参考:http://www.dabeaz.com/coroutines/   作者:David Beazley 缘起: 本人最近在学习python的协程.偶然发现了David Beazley的co ...

  6. 关于Python的协程问题总结

    协程其实就是可以由程序自主控制的线程 在python里主要由yield 和yield from 控制,可以通过生成者消费者例子来理解协程 利用yield from 向生成器(协程)传送数据# 传统的生 ...

  7. 协程,greenlet原生协程库, gevent库

    协程简介 协程(coroutine),又称为微线程,纤程,是一种用户级的轻量级线程.协程拥有自己的寄存器上下文和栈. 协程调度切换时,将寄存器上下文和栈保存到其他地方,在切回来时,恢复之前保存的上下文 ...

  8. python gevent 协程

    简介 没有切换开销.因为子程序切换不是线程切换,而是由程序自身控制,没有线程切换的开销,因此执行效率高, 不需要锁机制.因为只有一个线程,也不存在同时写变量冲突,在协程中控制共享资源不加锁,只需要判断 ...

  9. {python之协程}一 引子 二 协程介绍 三 Greenlet 四 Gevent介绍 五 Gevent之同步与异步 六 Gevent之应用举例一 七 Gevent之应用举例二

    python之协程 阅读目录 一 引子 二 协程介绍 三 Greenlet 四 Gevent介绍 五 Gevent之同步与异步 六 Gevent之应用举例一 七 Gevent之应用举例二 一 引子 本 ...

随机推荐

  1. 经典排序算法 — C#版本(中)

    归并排序比较适合大规模得数据排序,借鉴了分治思想. 归并排序原理 自古以来,分久必合合久必分. 我们可以这样理解归并排序,分-分到不能分为止,然后合并. 使用递归将问题一点一点分解,最后进行合并. 分 ...

  2. .NET Core TDD 前传: 编写易于测试的代码 -- 单一职责

    第1篇: 讲述了如何创造"缝".  "缝"(seam)是需要知道的概念. 第2篇, 避免在构建对象时写出不易测试的代码. 第3篇, 依赖项和迪米特法则. 第4篇 ...

  3. Nodejs+Express 搭建 web应用

    简单的记录下关于如何使用nodejs+Express 极速搭建一个web应用. 项目所需,要用到nodejs,那就去学咯.简单的看了下 七天学会NodeJS,Node.js 教程.发现其实好简单的,分 ...

  4. mybatis自动填充时间字段

    对于实体中的created_on和updated_on来说,它没有必要被开发人员去干预,因为它已经足够说明使用场景了,即在插入数据和更新数据时,记录当前时间,这对于mybatis来说,通过拦截器是可以 ...

  5. WebApiClient与Asp.net core DI的结合

    1 WebApiClient 一款基于HttpClient封装,只需要定义c#接口并修饰相关特性,即可异步调用远程http接口的客户端库 WebApiClient WebApiClient.Exten ...

  6. Vue基础(环境配置、内部指令、全局API、选项、内置组件)

    1.环境配置 安装VsCode 安装包管理工具:直接下载 NodeJS 进行安装即可,NodeJS自带 Npm 包管理工具,下载地址:https://nodejs.org/en/download/安装 ...

  7. Docker最全教程之使用Tencent Hub来完成CI(九)

    使用Tencent Hub来完成CI 关于Tencent Hub Tencent Hub是腾讯出品的DevOps服务.主要提供多存储格式的版本管理,支持Docker Image.Binary.Helm ...

  8. 🕵️ 如何绕过 BKY 对 script 的屏蔽

    Conmajia January 20, 2019 警告 这是试验,警告个屁,请不要多多尝试用它做多余的事. 果不其然,这篇文章立刻被移出主页了,我就说嘛,BKY 哪儿会那么包容和坦然呢? 原文 do ...

  9. 【1】Asp.Net Core2.2从环境配置到应用建立

    作者:Eleven 来源:公众号[软谋net] [前言] .Net Core开源&跨平台,已经肉眼可见将成为.Net平台的未来,在企业招聘需求上已经频频见到,接触到很多公司内部都已经开始尝试C ...

  10. c#导出文件,文件名中文乱码解决方法

    public string clFielName(string fileName) { System.Web.HttpContext curContext = System.Web.HttpConte ...