python 关于await/async 的思考（非理论）

最新推荐文章于 2024-03-19 14:04:12 发布
最新推荐文章于 2024-03-19 14:04:12 发布
阅读量286 收藏
点赞数
分类专栏： Python 日常 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41445357/article/details/108555239
版权

最近在学习python的异步，网上的很多资料 指向“协程”这个东西，在python3.4版本之后用的是await/async关键字。

如果大家读到这篇文章欢迎大家交流，我阅读过不少博客，基本提到 asyncio.sleep()来模拟实际的生产环境，但是在实际项目中我们并不会用到这个。

在探究 协程问题的时候，随便测试了Flask和Tornado框架，因为模拟爬虫吗，需要做个网页接口，测试结果非常奇怪，再访问Tornado服务器的时候没有并发，即使我用了多线程，多协程依然不行，但是Flask可以，之后为了排除框架的影响 使用time.sleep取代requests.get，发现效果和Flask一致，这我不禁开始怀疑Tornaod框架了。

后来通过查资料发现 如果用time.sleep是不对，应该用gen.sleep，因为time.sleep会阻断线程，因为tornado是单线程，肯定被阻塞啊，对于替换time.sleep没有贴代码，大家可以执行尝试，心塞啊。

在学习中我记录下学习的代码，异步在实际的表现，开发环境为3.7版本，asyncio这个库有些语法 3.7以前版本和3.7版本还是不一样的，会报错。

一、构建服务器（Flask,Tornado）

from flask import Flask
import time

app = Flask(__name__)

@app.route('/')
def index():
    time.sleep(3)
    return "Hello Word!"

if __name__ == "__main__":
    app.run(threaded = True,port=8000)

import tornado.ioloop
import tornado.web
import time

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        time.sleep(3)#模拟网页数据处理需要耗时三秒
        self.write("Hello, world")

def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ])

if __name__ == "__main__":
    app = make_app()
    app.listen(9000)
    tornado.ioloop.IOLoop.current().start()

二、测试Tornado环境下的线程、协程

1、单进程，单线程，无协程

import requests
import time
import asyncio
import threading

request_times = 100# 请求次数
Tornado_URL = "http://127.0.0.1:9000"
thread_num = 4 # 线程数

# 单进程 单线程 无协程
def request():
    for i in range(request_times):
        requests.get(Tornado_URL)
    
if __name__ == '__main__':
    start_time = time.time()
    request()
    end_time = time.time()
    print("Flask 单进程，单线程，无协程 执行时间为：.5f%",end_time-start_time)

 

2、单进程，多线程，无协程

import time
import asyncio
import threading

request_times = 100# 请求次数
Tornado_URL = "http://127.0.0.1:9000"
thread_num = 4 # 线程数

# 单进程 多线程 无协程
# 一共请求100次，采用四线程每个线程需要25次
def request():
    for i in range(request_times//thread_num):
        requests.get(Tornado_URL)
    
if __name__ == '__main__':
    pools = [threading.Thread(target=request) for i in range(thread_num)]
    start_time = time.time()
    for t in pools:
        t.setDaemon(True)#将线程声明为守护线程
        t.start()
    for t in pools:
        t.join() #阻塞主线程
    end_time = time.time()
    print("Tornado 单进程，4线程，无协程 执行时间为：.5f%",end_time-start_time)

看到这里你是不是有很多问号，我也一度怀疑是自己的程序写错了，因为按照逻辑来说，多线程肯定比单线程要快的，可这运行时间竟然还超了，因为有线程切换，这个可以理解，但是没有并发就痛苦了。 

3、单进程，单线程，多协程

import requests
import time
import asyncio
import threading

request_times = 100# 请求次数
Tornado_URL = "http://127.0.0.1:9000"
thread_num = 4 # 线程数

# 单进程，单线程，多协程，运行100次。我们拆成100个协程
async def request():
    future = loop.run_in_executor(None,requests.get,Tornado_URL)
    response = await future 

if __name__ == '__main__':
    start_time = time.time()
    # 开启 request_times 个协程
    loop = asyncio.get_event_loop()
    tasks = [asyncio.ensure_future(request()) for i in range(request_times)]
    loop.run_until_complete(asyncio.wait(tasks))
    loop.close()
    end_time = time.time()
    print("Tornado 单进程，单线程，多协程 执行时间为：.5f%",end_time-start_time)

看到这个结果我彻底凌乱了，说好的并行呢？要哭了啊，接下来的多线程多协程我都觉得没必要测了。

4、 单进程，多线程，多协程

import requests
import time
import asyncio
import threading

request_times = 100# 请求次数
Tornado_URL = "http://127.0.0.1:9000"
thread_num = 4 # 线程数

# 单进程，多线程，多协程
async def request(loop):
    future = loop.run_in_executor(None,requests.get,Tornado_URL)
    response = await future
    
def taskc_request():
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)
    tasks = [asyncio.ensure_future(request(loop)) for i in range(request_times//thread_num)]
    loop.run_until_complete(asyncio.wait(tasks))
    loop.close()
    
if __name__ == '__main__':
    pools = [threading.Thread(target=taskc_request) for i in range(thread_num)]
    start_time = time.time()
    for t in pools:
        t.setDaemon(True)#将线程声明为守护线程
        t.start()
    for t in pools:
        t.join() #阻塞主线程
    end_time = time.time()
    print("Tornado 单进程，4线程，25协程 执行时间为：.5f%",end_time-start_time)

结果不出所料，线程，协程都试了，那就试试进程吧

5、双进程，单线程，无协程

import requests
import time
import asyncio
import threading
from multiprocessing import Process

request_times = 100# 请求次数
Tornado_URL = "http://127.0.0.1:9000"
process_num = 2 # 进程数

# 双进程 单线程 无协程
# 一共请求100次，采用双进程每个进程需要50次
def request():
    for i in range(request_times//process_num):
        requests.get(Tornado_URL)
    
if __name__ == '__main__':
    start_time = time.time()
    pools = [Process(target=request) for i in range(process_num)]
    for t in pools:
        t.daemon=True#开启守护进程
        t.start()
    for t in pools:
        t.join()
    end_time = time.time()
    print("Tornado 双进程，单线程，无协程 执行时间为：.5f%",end_time-start_time)

疯了疯了 这都是啥 差点以为 死机了。

后来发现 time.sleep会阻塞整个tornado线程，应该使用gen.sleep，来看看速度

三、为了验证 我试了Flask服务器

仅仅将上面的URL中端口改了就行，Tornado是9000设定的是9000端口，Flask设为8000端口

1、单进程，单线程，无协程

PS:上面的提示信息忘记改了，应该是单线程 

2、单进程，多线程，无协程

3、单进程，单线程，多协程（100协程）

4、单进程，多线程，多协程

 5、双进程，单线程，无协程

十分神奇，访问Flask服务器竟然可以并发，难道是我理解错了？Tornado不是异步框架吗？ 

四、以time.sleep取代向网络发送请求，排除 tornado和flask框架的不同

取代方式time.sleep 取代 requests.get 

1、单进程 单线程 多协程

import requests
import time
import asyncio
import threading

request_times = 100# 请求次数
thread_num = 4 # 线程数

# 单进程，单线程，多协程
async def request(loop):
    future = loop.run_in_executor(None,time.sleep,3)
    response = await future
    
if __name__ == '__main__':
    start_time = time.time()
    loop = asyncio.get_event_loop()
    asyncio.set_event_loop(loop)
    tasks = [asyncio.ensure_future(request(loop)) for i in range(request_times)]
    loop.run_until_complete(asyncio.wait(tasks))
    loop.close()
    end_time = time.time()
    print("Time 单进程，单线程，多协程 执行时间为：.5f%",end_time-start_time)

2、单进程 4线程 无协程

import requests
import time
import asyncio
import threading

request_times = 100# 请求次数
thread_num = 4 # 线程数

# 单进程，多线程，无协程
def request():
    for i in range(request_times//thread_num):
        time.sleep(3)
    
if __name__ == '__main__':
    pools = [threading.Thread(target=request) for i in range(thread_num)]
    start_time = time.time()
    for t in pools:
        t.setDaemon(True)#将线程声明为守护线程
        t.start()
    t.join() #阻塞主线程
    end_time = time.time()
    print("Time 单进程，4线程，无协程 执行时间为：.5f%",end_time-start_time)

 

3、单进程 4线程 25协程

import requests
import time
import asyncio
import threading

request_times = 100# 请求次数
thread_num = 4 # 线程数

# 单进程，单线程，多协程
async def request(loop):
    future = loop.run_in_executor(None,time.sleep,3)
    response = await future

def taskc_request():
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)
    tasks = [asyncio.ensure_future(request(loop)) for i in range(request_times//thread_num)]
    loop.run_until_complete(asyncio.wait(tasks))
    loop.close()
    
if __name__ == '__main__':
    pools = [threading.Thread(target=taskc_request) for i in range(thread_num)]
    start_time = time.time()
    for t in pools:
        t.setDaemon(True)#将线程声明为守护线程
        t.start()
    t.join() #阻塞主线程
    end_time = time.time()
    print("Time 单进程，4线程，25协程 执行时间为：.5f%",end_time-start_time)

五、总结

协程真香。

江湖人称王某人的程序员
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Python async, await 的理解与使用
pydby01的博客
12-19 5330
关于 Python 中 async, await 关键字的一些知识在去年的一篇探索 Flask 对 asyncio 的支持有讲到，一直没在实际上用过它们，所以基本上也就忘干净了。随着Flask2 加入了 async 的特性，以及 FastAPI 从一开始支持 async, 又觉得有必要重新温习一下 Python 中如何使用 async, await 关键字了。 注：由于 Flask 支持了 async, 号称 async 化 Flask 的Quart项目开始变得无足轻重了。 本文主要的学习材...
python异步--asyncio
HWQlet的博客
05-23 461
在python2.x和python3.x早期版本的时候，协程的主流实现方法是gevent，这个我之前讲过 asyncio在python3.4后内置在python中了，在后面还有async/await，更后面有aiohttp，flask实现就有参照aiohttp async和await分别又来替换早期协程的asyncio.coroutine和yield from。 从此以后，协程就是python中一个新的语法，而不是与生成器混为一谈了 事件循环和协程的引入，可以极大提高高负载下程序的IO能力 asy
python中的async和await用法
最新发布
陶将的博客
03-19 1590
此篇文章介绍了python语言异步编程中async和await的用法
当Python遇上异步编程：实现高效、快速的程序运行！
南宫乘风-Linux运维-虚拟化容器-Python编程 ownit.top
05-19 1599
同步/异步的概念：同步是指完成事务的逻辑，先执行第一个事务，如果阻塞了，会一直等待，直到这个事务完成，再执行第二个事务，顺序执行异步是和同步相对的，异步是指在处理调用这个事务的之后，不会等待这个事务的处理结果，直接处理第二个事务去了，通过状态、通知、回调来通知调用者处理结果。asyncio是python3.4版本引入到标准库python3.5又加入了async/await特性。
Python3.5后 async/await（coroutine）使用问题总结
北游的日常
07-01 9838
前言 在最近的项目中，需要实现一个周期性执行的定时器。第一个想法是用celery，但是看了一下之后发现针对这个简单的需求，celery还是太大了，有点杀鸡焉用牛刀的感觉。正好之前在看coroutine的东西，于是就在这方面试试。但是也遇到了好多问题吧，本文就是针对这些问题的总结，希望对大家有所帮助。 先放两个链接，是我学习coroutine时候看到的，感觉...
在python子程序中、使用关键字_在python里使用await关键字来等另外一个协程的实例...
weixin_39890452的博客
11-29 127
一个协程里可以启动另外一个协程，并等待它完成返回结果，采用await关键字，例子如下：import asyncioasync def outer():print('in outer')print('waiting for result1')result1 = await phase1()print('waiting for result2')result2 = await phase2(resul...
python异步编程入门 async/await/asyncio
06-15
无论是micropython还是python3.5+，都有async/await/asyncio。 本教程不会去深入讲解异步底层的实现。 但会通过数个实例来简单讲解如何使用async/await/asyncio，让大家快速了解异步编程。 本教程所使用的python...
Python从使用线程到使用async/await的深入讲解
09-20
Python在3.5版本中引入了关于协程的语法糖async和await，所以下面这篇文章主要给大家介绍了关于Python从使用线程到使用async/await的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考下
Python3.5中async_await特性的实现.pdf
08-21
Python3.5中async_await特性的实现.pdf
python async with和async for的使用
12-31
网上async with和async for的中文资料比较少，我把PEP 492中的官方陈述翻译一下。 异步上下文管理器”async with” 异步上下文管理器指的是在enter和exit方法处能够暂停执行的上下文管理器。 为了实现这样的功能，...
python 协程 await_python3协程await使用问题
weixin_30425639的博客
02-03 499
import asyncioasync def wget(hots):print('wget %s...' % hots)content=asyncio.open_connection(hots,80)reader, writer = await contentheader='GET / HTTP / 1.0 \r\n Host:%s\r\n\n' % hotsawait writer.write...
Python-Flaskaiohttp使用aiohttp的异步Flask
08-10
Flask-aiohttp-使用 aiohttp 的异步 Flask
Python 中的 async await到底是什么？
weixin_38933749的博客
09-26 1774
前言 我希望能用一个最平易近人的例子, 把 Python 协程中的 async/await 概念讲清楚, 希望能够帮助大家有一个形象化的认识。 注: 所有的讲解都在代码的注释里. from time import sleep, time def demo1(): """ 假设我们有三台洗衣机, 现在有三批衣服需要分别放到这三台洗衣机里面洗. """ def washing1(): sleep(3) # 第一台洗衣机, 需要洗3秒才能洗完 (只是
python 等待线程结束,Python：如何不等待线程完成？
weixin_39854369的博客
11-26 410
So I have some code that waits for X to happen, then creates a thread and does processEmail.What I am looking for is a way for the code to carry on waiting X even though processEmail is happening in a...
探索 Flask 对 asyncio 的支持
一叶不知秋
07-16 3879
源于自己折腾的一个小 Flask 项目中，后台需访问多个 HTTP 服务，目前采用 ThreadPoolExecutor 多线程的方式处理的。但因访问 HTTP 服务有前后关联关系，如得到请求 A 的结果后再访问 B，这似乎用 Promise.then().then() 编程方式更合适些。于是巡着这一路子，翻出 Python 的各种相关部件来，比如 Python 对 coroutine(协程) 的支持，asyncio, 及后面的 async/await 关键子，aiohttp组件，requests 的 a.
python协程---2 await使用方式
田晨丿ggss
07-27 7073
await使用原则 await + 可等待对象（协程对象，future，task ->== io等待） 1.1 await + 协程对象 import asyncio async def func1(): print(1) await asyncio.sleep(2) print(2) return "返回值" async def func2(): print(3) await func1() print(4) return "返回值"
Python并发编程【(一)理论】：多线程thread、多进程Process、协程Coroutine(async await)
*
12-19 2777
Python对并发编程的支持 ●多线程: threading, 利用CPU和IO可以同时执行的原理,让CPU不会干巴巴等待IO完成 ●多进程: multiprocessing, 利用多核CPU的能力，真正的并行执行任务 ●异步IO: asyncio, 在单线程利用CPU和IO同时执行的原理，实现函数异步执行， ●使用Lock对资源加锁，防止冲突访问 ●便用Queue实现不同线程/进程之间的数据通信，实现生产者-消费者模式 ●使用线程池Pool/是程池Pool,简化线程/进程的任务提交、等待结束、获取结果 ●
python 异步操作async和await
热门推荐
alex1801
01-29 1万+
asyncio是"多任务合作"模式（cooperative multitasking），允许异步任务交出执行权给其他任务，等到其他任务完成，再收回执行权继续往下执行。协程（Co-routine），也可称为微线程，或非抢占式的多任务子例程，一种用户态的上下文切换技术（通过一个线程实现代码块间的相互切换执行）。我们从asyncio模块中直接获取一个EventLoop的引用，然后把需要执行的协程扔到EventLoop中执行，就实现了异步IO。携程对象：执行携程函数 函数名()，得到的就是携程对象。
对python async与await的理解
aiyie5748的博客
11-10 1288
async/await关键字是出现在python3.4以后。网上已经有很多文章对async/await这两个关键字都有讲解，包括如何由python2的yield from发展到async/await这两个关键字，以及一些代码实现都有。但是对于像我这样初次接触的人来说，光看代码分析也不一定能理解，我也是在度娘上搜索很多相关的网站，当中也有官网，都没有发现能让我一眼看懂在什么...
Task与await/async使用异步操作代码
05-17
异步操作代码通常与`async`和`await`关键字一起使用。`async`用于标记一个函数为异步函数，而`await`用于等待异步操作完成。以下是一个使用异步操作代码的示例： ```python import asyncio async def fetch_data()...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

江湖人称王某人的程序员

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值