@[toc]
asyncio 异步模块使用教程
1. 异步编程基础概念
1.1 什么是异步编程
异步编程是一种非阻塞的编程范式，允许程序在等待I/O操作（如网络请求、文件读写）完成时执行其他任务，而不是干等。
1.2 事件循环(Event Loop)
事件循环是asyncio的核心，负责调度和执行异步任务。它不断检查并执行以下操作：
- 执行可运行的协程
- 处理I/O事件
- 执行回调函数
- 处理子进程
1.3 协程(Coroutine)
协程是asyncio的基本执行单元，使用async def定义的函数：
async def my_coroutine():
await asyncio.sleep(1)
return "Done"
1.4 Future和Task
- Future: 表示异步操作的最终结果
- Task: Future的子类，用于包装和管理协程的执行
2. 基本用法
2.1 创建和运行协程
import asyncio
async def hello_world():
print("Hello")
await asyncio.sleep(1)
print("World")
# Python 3.7+ 推荐方式
asyncio.run(hello_world())
# 旧版本方式
# loop = asyncio.get_event_loop()
# loop.run_until_complete(hello_world())
# loop.close()
2.2 创建任务(Task)
async def main():
task1 = asyncio.create_task(hello_world())
task2 = asyncio.create_task(hello_world())
await task1
await task2
asyncio.run(main())
2.3 并发运行多个协程
async def fetch_data(delay, id):
print(f"Fetching data {id}...")
await asyncio.sleep(delay)
print(f"Data {id} fetched")
return {"id": id, "delay": delay}
async def main():
results = await asyncio.gather(
fetch_data(2, 1),
fetch_data(1, 2),
fetch_data(3, 3),
)
print(results)
asyncio.run(main())
3. 核心API详解
3.1 事件循环管理
3.1.1 获取事件循环
loop = asyncio.get_event_loop()
3.1.2 运行直到完成
loop.run_until_complete(coro)
3.1.3 运行永久
loop.run_forever()
3.1.4 停止事件循环
loop.stop()
3.2 协程控制
3.2.1 asyncio.sleep
await asyncio.sleep(1) # 休眠1秒
3.2.2 asyncio.gather
results = await asyncio.gather(
coro1(),
coro2(),
return_exceptions=True # 异常时返回异常对象而不是抛出
)
3.2.3 asyncio.wait
done, pending = await asyncio.wait(
[coro1(), coro2()],
timeout=2,
return_when=asyncio.FIRST_COMPLETED
)
3.2.4 asyncio.shield
task = asyncio.create_task(coro())
await asyncio.shield(task) # 防止任务被取消
3.3 任务管理
3.3.1 创建任务
task = asyncio.create_task(coro())
3.3.2 取消任务
task.cancel()
try:
await task
except asyncio.CancelledError:
print("Task was cancelled")
3.3.3 设置超时
try:
await asyncio.wait_for(coro(), timeout=1.0)
except asyncio.TimeoutError:
print("Timeout!")
4. 高级特性
4.1 异步上下文管理器
class AsyncResource:
async def __aenter__(self):
print("Opening resource")
await asyncio.sleep(1)
return self
async def __aexit__(self, exc_type, exc, tb):
print("Closing resource")
await asyncio.sleep(1)
async def main():
async with AsyncResource() as resource:
print("Using resource")
asyncio.run(main())
4.2 异步迭代器
class AsyncCounter:
def __init__(self, stop):
self.current = 0
self.stop = stop
def __aiter__(self):
return self
async def __anext__(self):
if self.current < self.stop:
await asyncio.sleep(1)
self.current += 1
return self.current
else:
raise StopAsyncIteration
async def main():
async for i in AsyncCounter(3):
print(i)
asyncio.run(main())
4.3 异步生成器
async def async_gen():
for i in range(3):
await asyncio.sleep(1)
yield i
async def main():
async for item in async_gen():
print(item)
asyncio.run(main())
5. 与同步代码交互
5.1 在异步中运行同步代码
import time
def blocking_io():
time.sleep(1)
return "Blocking IO done"
async def main():
loop = asyncio.get_running_loop()
# 1. 在默认线程池中运行
result = await loop.run_in_executor(
None, blocking_io
)
print(result)
# 2. 在自定义线程池中运行
# with concurrent.futures.ThreadPoolExecutor() as pool:
# result = await loop.run_in_executor(
# pool, blocking_io
# )
# print(result)
asyncio.run(main())
5.2 在同步中运行异步代码
def sync_main():
return asyncio.run(async_main())
async def async_main():
await asyncio.sleep(1)
return "Done"
print(sync_main())
6. 常见问题
6.1 常见错误
- 忘记await：导致协程没有实际执行
- 混合阻塞和非阻塞代码：在协程中调用阻塞函数
- 不正确的任务取消处理：没有正确处理CancelledError
- 事件循环嵌套：在已有事件循环中创建新循环
6.2 注意事项
- 使用async/await语法：替代旧式的@asyncio.coroutine和yield from
- 合理设置并发限制：避免资源耗尽
- 正确处理异常：特别是CancelledError
- 使用结构化并发：通过async with管理资源
- 避免CPU密集型任务：asyncio适合I/O密集型场景
6.3 性能优化
- 减少await次数：批量处理任务
- 使用uvloop：替代默认事件循环提升性能
import uvloop
uvloop.install()
合理设置缓冲区大小：在网络编程中调整读写缓冲区
7. 实际应用示例
7.1 异步爬虫
import aiohttp
async def fetch_url(session, url):
async with session.get(url) as response:
return await response.text()
async def main():
async with aiohttp.ClientSession() as session:
tasks = [
fetch_url(session, "http://example.com") for _ in range(5)
]
results = await asyncio.gather(*tasks)
print(f"Fetched {len(results)} pages")
asyncio.run(main())
7.2 异步数据库访问
import asyncpg
async def fetch_data():
conn = await asyncpg.connect(
user='user', password='pass',
database='db', host='localhost')
try:
result = await conn.fetch('SELECT * FROM table')
return result
finally:
await conn.close()
asyncio.run(fetch_data())
7.3 异步Web框架(FastAPI)
from fastapi import FastAPI
import asyncio
app = FastAPI()
@app.get("/")
async def read_root():
await asyncio.sleep(1)
return {"Hello": "World"}
@app.get("/items/{item_id}")
async def read_item(item_id: int):
return {"item_id": item_id}
asyncio与aiohttp使用教程
asyncio可以实现单线程并发IO操作。如果仅用在客户端，发挥的威力不大。如果把asyncio用在服务器端，例如Web服务器，由于HTTP连接就是IO操作，因此可以用单线程+coroutine实现多用户的高并发支持。
asyncio实现了TCP、UDP、SSL等协议，aiohttp则是基于asyncio实现的HTTP框架。
- 对于异步io你需要知道的重点，要注意的是，await语法只能出现在通过async修饰的函数中，否则会报SyntaxError错误。而且await后面的对象需要是一个Awaitable，或者实现了相关的协议。
注意：
- 所有需要异步执行的函数，都需要asyncio中的轮训器去轮训执行，如果函数阻塞，轮训器就会去执行下一个函数。所以所有需要异步执行的函数都需要加入到这个轮训器中。
asyncio
asyncio的基本概念asyncio是在python3.4中被引进的异步IO库。有两件事情你需要知道：协同程序和事件循环。协同程序像是方法，但是它们可以在代码中的特定点暂停和继续。当在等待一个IO(比如一个HTTP请求)，同时执行另一个请求的时候，可以用来暂停一个协同程序。
例如：
import requests
import time
import asyncio
# 创建一个异步函数
async def task_func():
await asyncio.sleep(1)
resp = requests.get('http://192.168.2.177:5002/')
print('2222222',time.time(),resp.text)
async def main(loop):
loop=asyncio.get_event_loop() # 获取全局轮训器
task = loop.create_task(task_func()) # 在全局轮训器加入协成，只有加入全局轮训器才能被监督执行
await asyncio.sleep(2) # 等待两秒为了不要立即执行event_loop.close()，项目中event_loop应该是永不停歇的
print('11111111111',time.time())
event_loop = asyncio.get_event_loop()
try:
event_loop.run_until_complete(main(event_loop))
finally:
event_loop.close() # 当轮训器关闭以后，所有没有执行完成的协成将全部关闭
所谓「异步 IO」，就是你发起一个 IO 操作，却不用等它结束，你可以继续做其他事情，当它结束时，你会得到通知。
Asyncio 是并发（concurrency）的一种方式。对 Python 来说，并发还可以通过线程（threading）和多进程（multiprocessing）来实现。
Asyncio 并不能带来真正的并行（parallelism）。当然，因为 GIL（全局解释器锁）的存在，Python 的多线程也不能带来真正的并行。
可交给 asyncio 执行的任务，称为协程（coroutine）。一个协程可以放弃执行，把机会让给其它协程（即 yield from 或 await）。
定义协程
协程的定义，需要使用 async def 语句。
async def do_some_work(x): pass
do_some_work 便是一个协程。准确来说，do_some_work 是一个协程函数，可以通过 asyncio.iscoroutinefunction 来验证：
print(asyncio.iscoroutinefunction(do_some_work)) # True
这个协程什么都没做，我们让它睡眠几秒，以模拟实际的工作量 ：
async def do_some_work(x):
print("Waiting " + str(x))
await asyncio.sleep(x)
在解释 await 之前，有必要说明一下协程可以做哪些事。协程可以：
- 等待一个 future 结束
- 等待另一个协程（产生一个结果，或引发一个异常）
- 产生一个结果给正在等它的协程
- 引发一个异常给正在等它的协程
asyncio.sleep 也是一个协程，所以 await asyncio.sleep(x) 就是等待另一个协程。可参见 asyncio.sleep 的文档：
sleep(delay, result=None, *, loop=None)
Coroutine that completes after a given time (in seconds).
运行协程
调用协程函数，协程并不会开始运行，只是返回一个协程对象，可以通过 asyncio.iscoroutine 来验证：
print(asyncio.iscoroutine(do_some_work(3))) # True
此处还会引发一条警告：
async1.py:16: RuntimeWarning: coroutine 'do_some_work' was never awaited
print(asyncio.iscoroutine(do_some_work(3)))
要让这个协程对象运行的话，有两种方式：
- 在另一个已经运行的协程中用
await等待它 - 通过
ensure_future函数计划它的执行
简单来说，只有 loop 运行了，协程才可能运行。
下面先拿到当前线程缺省的 loop ，然后把协程对象交给 loop.run_until_complete，协程对象随后会在 loop 里得到运行。
loop = asyncio.get_event_loop()
loop.run_until_complete(do_some_work(3))
run_until_complete 是一个阻塞（blocking）调用，直到协程运行结束，它才返回。这一点从函数名不难看出。
run_until_complete 的参数是一个 future，但是我们这里传给它的却是协程对象，之所以能这样，是因为它在内部做了检查，通过 ensure_future 函数把协程对象包装（wrap）成了 future。所以，我们可以写得更明显一些：
loop.run_until_complete(asyncio.ensure_future(do_some_work(3)))
完整代码：
import asyncio
async def do_some_work(x):
print("Waiting " + str(x))
await asyncio.sleep(x)
loop = asyncio.get_event_loop()
loop.run_until_complete(do_some_work(3))
运行结果：
Waiting 3
<三秒钟后程序结束>
回调
假如协程是一个 IO 的读操作，等它读完数据后，我们希望得到通知，以便下一步数据的处理。这一需求可以通过往 future 添加回调来实现。
def done_callback(futu):
print('Done')
futu = asyncio.ensure_future(do_some_work(3))
futu.add_done_callback(done_callback)
loop.run_until_complete(futu)
多个协程
实际项目中，往往有多个协程，同时在一个 loop 里运行。为了把多个协程交给 loop，需要借助 asyncio.gather 函数。
loop.run_until_complete(asyncio.gather(do_some_work(1), do_some_work(3)))
或者先把协程存在列表里：
coros = [do_some_work(1), do_some_work(3)]
loop.run_until_complete(asyncio.gather(*coros))
运行结果：
Waiting 3
Waiting 1
<等待三秒钟>
Done
这两个协程是并发运行的，所以等待的时间不是 1 + 3 = 4 秒，而是以耗时较长的那个协程为准。
参考函数 gather 的文档：
gather(*coros_or_futures, loop=None, return_exceptions=False)>
Return a future aggregating results from the given coroutines or futures.
发现也可以传 futures 给它：
futus = [asyncio.ensure_future(do_some_work(1)),
asyncio.ensure_future(do_some_work(3))]
loop.run_until_complete(asyncio.gather(*futus))
gather 起聚合的作用，把多个 futures 包装成单个 future，因为 loop.run_until_complete 只接受单个 future。
run_until_complete 和 run_forever
我们一直通过 run_until_complete 来运行 loop ，等到 future 完成，run_until_complete 也就返回了。
async def do_some_work(x):
print('Waiting ' + str(x))
await asyncio.sleep(x)
print('Done')
loop = asyncio.get_event_loop()
coro = do_some_work(3)
loop.run_until_complete(coro)
输出：
Waiting 3
<等待三秒钟>
Done
<程序退出>
现在改用 run_forever：
async def do_some_work(x):
print('Waiting ' + str(x))
await asyncio.sleep(x)
print('Done')
loop = asyncio.get_event_loop()
coro = do_some_work(3)
asyncio.ensure_future(coro)
loop.run_forever()
输出：
Waiting 3
<等待三秒钟>
Done
<程序没有退出>
三秒钟过后，future 结束，但是程序并不会退出。run_forever 会一直运行，直到 stop 被调用，但是你不能像下面这样调 stop：
loop.run_forever()
loop.stop()
run_forever 不返回，stop 永远也不会被调用。所以，只能在协程中调 stop：
async def do_some_work(loop, x):
print('Waiting ' + str(x))
await asyncio.sleep(x)
print('Done')
loop.stop()
这样并非没有问题，假如有多个协程在 loop 里运行：
asyncio.ensure_future(do_some_work(loop, 1))
asyncio.ensure_future(do_some_work(loop, 3))
loop.run_forever()
第二个协程没结束，loop 就停止了——被先结束的那个协程给停掉的。 要解决这个问题，可以用 gather 把多个协程合并成一个 future，并添加回调，然后在回调里再去停止 loop。
async def do_some_work(loop, x):
print('Waiting ' + str(x))
await asyncio.sleep(x)
print('Done')
def done_callback(loop, futu):
loop.stop()
loop = asyncio.get_event_loop()
futus = asyncio.gather(do_some_work(loop, 1), do_some_work(loop, 3))
futus.add_done_callback(functools.partial(done_callback, loop))
loop.run_forever()
其实这基本上就是 run_until_complete 的实现了，run_until_complete 在内部也是调用 run_forever。
Close Loop?
以上示例都没有调用 loop.close，好像也没有什么问题。所以到底要不要调 loop.close 呢？
简单来说，loop 只要不关闭，就还可以再运行。：
loop.run_until_complete(do_some_work(loop, 1))
loop.run_until_complete(do_some_work(loop, 3))
loop.close()
但是如果关闭了，就不能再运行了：
loop.run_until_complete(do_some_work(loop, 1))
loop.close()
loop.run_until_complete(do_some_work(loop, 3)) # 此处异常
建议调用 loop.close，以彻底清理 loop 对象防止误用。
gather vs. wait
asyncio.gather 和 asyncio.wait 功能相似。
coros = [do_some_work(loop, 1), do_some_work(loop, 3)]
loop.run_until_complete(asyncio.wait(coros))
具体差别可请参见 StackOverflow 的讨论：Asyncio.gather vs asyncio.wait。
Timer
C++ Boost.Asio 提供了 IO 对象 timer，但是 Python 并没有原生支持 timer，不过可以用 asyncio.sleep 模拟。
async def timer(x, cb):
futu = asyncio.ensure_future(asyncio.sleep(x))
futu.add_done_callback(cb)
await futu
t = timer(3, lambda futu: print('Done'))
loop.run_until_complete(t)
aiohttp
aiohttp服务器
下面是aiohttp作为服务器端的一个简单的demo。
# -*- coding:utf-8 -*-
import argparse,asyncio,time,datetime,base64,requests,json,logging
from aiohttp import web
import uvloop #windows环境不能安装这个包，linux环境可以
#uvloop用来代替asyncio默认事件循环，可以进一步加快异步I/O操作的速度。
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
routes = web.RouteTableDef()
@routes.get('/')
async def hello(request):
return web.Response(text="Hello, world")
# 定义一个路由映射，接收网址参数，post方式
@routes.post('/demo1/{name}')
async def demo1(request): # 异步监听，只要一有握手就开始触发，此时网址参数中的name就已经知道了，但是前端可能还没有完全post完数据。
name = request.match_info.get('name', "Anonymous") # 获取name
print(datetime.datetime.now()) # 触发视图函数的时间
data = await request.post() # 等待post数据完成接收，只有接收完成才能进行后续操作.data['key']获取参数
print(datetime.datetime.now()) # 接收post数据完成的时间
print('safety dect request start %s' % datetime.datetime.now())
result = {'name':name,'key':data['key']}
print('safety dect request finish %s, %s' % (datetime.datetime.now(),json.dumps(result)))
return web.json_response(result)
# 定义一个路由映射，设计到io操作
@routes.post('/demo2')
async def demo2(request): # 异步监听，只要一有握手就开始触发，此时网址参数中的name就已经知道了，但是前端可能还没有完全post完数据。
data = await request.post() # 等待post数据完成接收，只有接收完成才能进行后续操作.data['key']获取参数
print('safety dect request start %s' % datetime.datetime.now())
res = requests.post('http://www.baidu.com') # 网路id，会自动切换到其他协成上
print('safety dect request finish %s' % res.test)
return web.Response(text="welcome")
if __name__ == '__main__':
print('server start')
app = web.Application()
app.add_routes(routes)
web.run_app(app,host='0.0.0.0',port=8080)
print('server close')
aiohttp客户端
aiohttp的另一个主要作用是作为异步客户端，用来解决高并发请求的情况。比如现在我要模拟一个高并发请求来测试我的服务器负载情况。所以需要在python里模拟高并发。高并发可以有多种方式，比如多线程，但是由于python本质上是没有多线程的，通过底层线程锁实现的多线程。在模型高并发时，具有线程切换和线程开销的损耗。所以我们就可以使用多协成来实现高并发。
我们就可以使用aiohttp来模拟高并发客户端。demo如下，用来模拟多个客户端向指定服务器post图片。
# 异步并发客户端
class Asyncio_Client(object):
def __init__(self):
self.loop=asyncio.get_event_loop()
self.tasks=[]
# 将异步函数介入任务列表。后续参数直接传给异步函数
def set_task(self,task_fun,num,*args):
for i in range(num):
self.tasks.append(task_fun(*args))
# 运行，获取返回结果
def run(self):
back=[]
try:
f = asyncio.wait(self.tasks) # 创建future
self.loop.run_until_complete(f) # 等待future完成
finally:
pass
# 服务器高并发压力测试
class Test_Load():
total_time=0 # 总耗时
total_payload=0 # 总负载
total_num=0 # 总并发数
all_time=[]
# 创建一个异步任务，本地测试，所以post和接收几乎不损耗时间，可以等待完成，主要耗时为算法模块
async def task_func1(self,session):
begin = time.time()
# print('开始发送：', begin)
file=open(self.image, 'rb')
fsize = os.path.getsize(self.image)
self.total_payload+=fsize/(1024*1024)
data = {"image_id": "2", 'image':file}
r = await session.post(self.url,data=data) #只post，不接收
result = await r.json()
self.total_num+=1
# print(result)
end = time.time()
# print('接收完成：', end,',index=',self.total_num)
self.all_time.append(end-begin)
# 负载测试
def test_safety(self):
print('test begin')
async_client = Asyncio_Client() # 创建客户端
session = aiohttp.ClientSession()
for i in range(10): # 执行10次
self.all_time=[]
self.total_num=0
self.total_payload=0
self.image = 'xxxx.jpg' # 设置测试nayizhang
print('测试图片：', self.image)
begin = time.time()
async_client.set_task(self.task_func1,self.num,session) # 设置并发任务
async_client.run() # 执行任务
end=time.time()
self.all_time.sort(reverse=True)
print(self.all_time)
print('并发数量(个)：',self.total_num)
print('总耗时(s)：',end-begin)
print('最大时延(s)：',self.all_time[0])
print('最小时延(s)：', self.all_time[len(self.all_time)-1])
print('top-90%时延(s)：', self.all_time[int(len(self.all_time)*0.1)])
print('平均耗时(s/个)：',sum(self.all_time)/self.total_num)
print('支持并发率(个/s):',self.total_num/(end-begin))
print('总负载(MB)：',self.total_payload)
print('吞吐率(MB/S)：',self.total_payload/(end-begin)) # 吞吐率受上行下行带宽，服务器带宽，服务器算法性能诸多影响
time.sleep(3)
session.close()
print('test finish')
aiohttp服务器mvc（静态网页，模板，数据库，log）
aiohttp之添加静态资源路径
所谓静态资源，是指图片、js、css等文件。
以一个小项目来说明，下面是项目的目录结构：
.
├── static
│ ├── css
│ │ ├── base.css
│ │ ├── bootstrap.min.css
│ │ └── font-awesome.min.css
│ ├── font
│ │ ├── FontAwesome.otf
│ │ ├── fontawesome-webfont.eot
│ │ ├── fontawesome-webfont.svg
│ │ ├── fontawesome-webfont.ttf
│ │ └── fontawesome-webfont.woff
│ └── index.html
└── proxy_server.py
在proxy_server.py给2个静态文件目录static/css和static/font添加路由：
app.router.add_static('/css/',
path='static/css',
name='css')
app.router.add_static('/font/',
path='static/font',
name='font')
必需的2个参数：
- prefix：是静态文件的url的前缀，以/开始，在浏览器地址栏上显示在网站host之后，也用于index.html静态页面进行引用
- path：静态文件目录的路径，可以是相对路径，上面代码使用的static/css就是相对路径——相对于proxy_server.py所在路径。
加载的是index.html，下面是它引用静态资源的代码：
<!-- Bootstrap CSS -->
<link href="css/bootstrap.min.css" rel="stylesheet">
<!-- Base CSS -->
<link href="css/base.css" rel="stylesheet">
<!-- FA CSS -->
<link href="css/font-awesome.min.css" rel="stylesheet">
添加font的路径是因为/font-awesome.min.css需要使用：
如果修改前缀：
app.router.add_static('/css2017/',
path='static/css',
name='css')
虽然目录本身还是css，但通过add_static已经将它视为了css2017，在文件和浏览器中要想链接到css下的文件，必须使用css2017/xx.css来链接。
此外，如果加上show_index=True，就可以显示静态资源的目录索引了——默认是禁止访问的：
app.router.add_static('/css2017/',
path='static/css',
name='css',
show_index=True)
多进程+asyncio
由于python本身只能单线程，所以所谓的线程是通过线程锁实现的。现在必须要通过多进程实现更多的并发。
现在demo实现了使用多进程，每个进程都有一个asyncio
# -*- coding:utf-8 -*-
import asyncio,threading,os,aiohttp,multiprocessing
from multiprocessing import Queue ,Pool,Process
async def hello(name):
print('hello {} {}**********{}'.format(name,os.getpid(),threading.current_thread()))
#await asyncio.sleep(int(name))
await asyncio.sleep(1)
print('end:{} {}'.format(name,os.getpid()))
def process_start(*namelist):
tasks=[]
loop=asyncio.get_event_loop()
for name in namelist:
tasks.append(asyncio.ensure_future(hello(name)))
loop.run_until_complete(asyncio.wait(tasks))
def task_start(namelist):
i=0
lst=[]
flag=10
while namelist:
i+=1
l=namelist.pop()
lst.append(l)
if i==flag:
p=Process(target=process_start,args=lst)
p.start()
#p.join()
lst=[]
i=0
if namelist!=[]:
p=Process(target=process_start,args=lst)
p.start()
#p.join()
if __name__=='__main__':
# 测试使用多个进程来实现函数
namelist=list('0123456789'*10)
print(namelist)
task_start(namelist)
# 测试使用一个异步io来实现全部函数
# loop=asyncio.get_event_loop()
# tasks=[]
# namelist=list('0123456789'*10)
# for i in namelist:
# tasks.append(asyncio.ensure_future(hello(i)))
# loop.run_until_complete(asyncio.wait(tasks))
