Python异步编程深入:从协程到高性能并发

掌握 Python 异步编程与 asyncio 库 —— 提升高并发编程效率 本文介绍了 Python 中的异步编程与 `asyncio` 库,强调其在处理高并发场景下的优势。异步编程允许程序在等待 I/O 操作时执行其他任务,提高 CPU 利用率和系统吞吐量。文章详细解析了异步编程的基础概念,包括事件循环、协程和任务,以及如何使用 `asyncio` 创建并发任务。此外,还展示了如何构建一个异步 Web 爬虫,并探讨了高级用法,如异步上下文管理器、迭代器和队列。最后,提供了性能优化和最佳实践建议,帮助开发者写出高效、稳定的异步代码。 阅读详情

Python异步编程深入:从协程到高性能并发

引言

异步编程是提高Python应用性能的关键技术之一。通过事件循环和协程,我们可以在单线程中实现高并发处理。

本文将深入探讨Python异步编程的核心概念,包括协程、事件循环、任务管理和最佳实践。

一、协程基础

1.1 协程定义与创建

import asyncio

# 基本协程定义
async def hello():
    print("Hello")
    await asyncio.sleep(1)
    print("World")

# 运行协程
asyncio.run(hello())

# 协程作为函数
async def fetch_data(url):
    print(f"Fetching {url}")
    await asyncio.sleep(2)
    return {"url": url, "data": "sample"}

async def main():
    result = await fetch_data("https://api.example.com")
    print(result)

asyncio.run(main())

1.2 协程的状态

import asyncio

async def my_coroutine():
    await asyncio.sleep(1)
    return "done"

# 获取协程对象
coro = my_coroutine()
print(f"状态: {coro.send(None)}")  # 启动协程

# 协程状态转换
# PENDING -> RUNNING -> DONE
#        -> CANCELLED

二、事件循环

2.1 事件循环的作用

import asyncio

def main():
    # 获取或创建事件循环
    loop = asyncio.get_event_loop()
    
    # 运行协程直到完成
    loop.run_until_complete(hello())
    
    # 关闭事件循环
    loop.close()

if __name__ == "__main__":
    main()

2.2 自定义事件循环

import asyncio
import uvloop

# 使用uvloop替代默认事件循环
uvloop.install()

async def benchmark():
    tasks = [asyncio.sleep(0.1) for _ in range(1000)]
    await asyncio.gather(*tasks)

# uvloop提供更好的性能
asyncio.run(benchmark())

三、任务管理

3.1 创建任务

import asyncio

async def task_function(name, delay):
    print(f"Task {name} started")
    await asyncio.sleep(delay)
    print(f"Task {name} completed")
    return f"Result from {name}"

async def main():
    # 创建任务
    task1 = asyncio.create_task(task_function("A", 2))
    task2 = asyncio.create_task(task_function("B", 1))
    
    # 等待任务完成
    result1 = await task1
    result2 = await task2
    
    print(f"Results: {result1}, {result2}")

asyncio.run(main())

3.2 并发任务

import asyncio

async def fetch_url(url):
    print(f"Fetching {url}")
    await asyncio.sleep(1)
    return f"Data from {url}"

async def main():
    urls = [
        "https://api.example.com/1",
        "https://api.example.com/2",
        "https://api.example.com/3",
    ]
    
    # 并发执行所有任务
    tasks = [fetch_url(url) for url in urls]
    results = await asyncio.gather(*tasks)
    
    for result in results:
        print(result)

asyncio.run(main())

3.3 任务取消

import asyncio

async def long_running_task():
    try:
        print("Starting long task")
        for i in range(10):
            await asyncio.sleep(0.5)
            print(f"Progress: {i+1}/10")
        return "Completed"
    except asyncio.CancelledError:
        print("Task was cancelled")
        raise

async def main():
    task = asyncio.create_task(long_running_task())
    
    # 1秒后取消任务
    await asyncio.sleep(1)
    task.cancel()
    
    try:
        await task
    except asyncio.CancelledError:
        print("Main caught cancellation")

asyncio.run(main())

四、异步模式

4.1 生产者-消费者模式

import asyncio
from collections import deque

async def producer(queue):
    for i in range(5):
        await asyncio.sleep(1)
        item = f"Item {i}"
        await queue.put(item)
        print(f"Produced: {item}")

async def consumer(queue):
    while True:
        item = await queue.get()
        print(f"Consumed: {item}")
        queue.task_done()

async def main():
    queue = asyncio.Queue()
    
    # 创建任务
    producer_task = asyncio.create_task(producer(queue))
    consumer_task = asyncio.create_task(consumer(queue))
    
    # 等待生产者完成
    await producer_task
    
    # 等待队列清空
    await queue.join()
    
    # 取消消费者
    consumer_task.cancel()

asyncio.run(main())

4.2 超时处理

import asyncio

async def slow_operation():
    await asyncio.sleep(5)
    return "Done"

async def main():
    try:
        # 设置超时
        result = await asyncio.wait_for(slow_operation(), timeout=2)
        print(result)
    except asyncio.TimeoutError:
        print("Operation timed out")

asyncio.run(main())

4.3 信号量控制并发

import asyncio

async def limited_task(semaphore, task_id):
    async with semaphore:
        print(f"Task {task_id} started")
        await asyncio.sleep(1)
        print(f"Task {task_id} completed")

async def main():
    # 限制并发数为3
    semaphore = asyncio.Semaphore(3)
    
    tasks = [limited_task(semaphore, i) for i in range(10)]
    await asyncio.gather(*tasks)

asyncio.run(main())

五、异步IO操作

5.1 异步文件操作

import asyncio

async def read_file_async(file_path):
    async with asyncio.open(file_path, 'r') as f:
        contents = await f.read()
        return contents

async def write_file_async(file_path, content):
    async with asyncio.open(file_path, 'w') as f:
        await f.write(content)

async def main():
    content = await read_file_async('input.txt')
    await write_file_async('output.txt', content)

asyncio.run(main())

5.2 异步HTTP客户端

import httpx

async def fetch_data(url):
    async with httpx.AsyncClient() as client:
        response = await client.get(url)
        return response.json()

async def main():
    urls = [
        "https://api.github.com/users/octocat",
        "https://api.github.com/repos/python/cpython"
    ]
    
    tasks = [fetch_data(url) for url in urls]
    results = await asyncio.gather(*tasks)
    
    for result in results:
        print(result)

asyncio.run(main())

六、异步最佳实践

6.1 避免阻塞调用

import asyncio
import time

# 错误:同步sleep阻塞事件循环
async def bad_example():
    print("Start")
    time.sleep(1)  # 阻塞!
    print("End")

# 正确:使用异步sleep
async def good_example():
    print("Start")
    await asyncio.sleep(1)  # 非阻塞
    print("End")

6.2 使用asyncio.to_thread

import asyncio

def blocking_io():
    """阻塞IO操作"""
    with open('large_file.txt', 'r') as f:
        return f.read()

async def main():
    # 将阻塞操作移到线程池
    result = await asyncio.to_thread(blocking_io)
    print(f"Read {len(result)} characters")

asyncio.run(main())

6.3 异步上下文管理器

import asyncio

class AsyncResource:
    async def __aenter__(self):
        print("Acquiring resource")
        await asyncio.sleep(0.1)
        return self
    
    async def __aexit__(self, exc_type, exc, tb):
        print("Releasing resource")
        await asyncio.sleep(0.1)
    
    async def do_work(self):
        print("Doing work")

async def main():
    async with AsyncResource() as resource:
        await resource.do_work()

asyncio.run(main())

七、总结

Python异步编程的核心概念:

  1. 协程:轻量级的并发执行单元
  2. 事件循环:协调协程执行的核心
  3. 任务:协程的封装和管理
  4. 并发模式:生产者-消费者、信号量控制等

在实际项目中,建议:

  • 使用asyncio进行异步编程
  • 避免在协程中调用阻塞函数
  • 使用httpx等异步库
  • 合理控制并发数量

思考:在你的项目中,异步编程带来了哪些性能提升?欢迎分享!

深入理解Python异步编程:从协程到高性能IO密集型应用 Python异步编程正彻底改变IO密集型应用的开发方式。本文将深入解析Python协程与事件循环的工作原理,对比不同并发模型的性能差异,并分享连接池管理、生产者-消费者模式等高级异步技巧。通过实现一个高性能Web爬虫案例,展示如何利用asyncio构建可扩展的微服务架构。文章还将揭示常见异步陷阱及其解决方案,帮助开发者充分发挥Python异步编程的性能优势,在保持开发效率的同时获得接近系统级语言的吞吐能力。 阅读详情

相关推荐

Python异步编程终极指南:用协程与事件循环重构你的高并发系统

🚀 深入剖析Python异步编程的核心机制。事件循环的底层实现原理与调度算法async/await协程的6种高级用法模式异步HTTP请求的性能优化技巧(速度提升15倍+)常见异步陷阱的26种解决方案从事件循环的底层原理到十万级并发的工程实践,异步编程将彻底改变您对Python性能的认知。立即动手,让您的应用性能飞升!编程智域 前端至全栈交流与成长Python异步编程终极指南:用协程与事件循环重构你的高并发系统 | cmdragon’s Blog。

https://blog.cmdragon.cn/ 1525

Python异步编程:从生成器到asyncio实战

异步编程是现代软件开发中处理高并发的关键技术,其核心是通过非阻塞I/O和任务调度提升系统吞吐量。Python生态通过生成器、装饰器到原生async/await语法逐步完善了异步支持,其中asyncio模块提供了完整的事件循环和协程管理方案。在Web爬虫、微服务等I/O密集型场景中,合理运用异步编程可显著提升性能。本文通过StopIteration异常处理、事件循环机制等核心概念解析,结合Semaphore控制、异常处理等工程实践,展示了如何构建高性能异步爬虫。针对协程协同、资源释放等常见问题,提供了实用的排

weixin_30768881的博客 311

Python 中的异步编程:提升程序性能的利器

通过使用协程,可以在等待一个耗时的操作时,让出 CPU 给其他任务执行,从而提高程序的并发性和性能。在传统的同步编程模型中,程序需要等待一个任务完成后才能执行下一个任务,而异步编程模型可以在等待某个任务的结果时同时执行其他任务,从而提高程序的效率和吞吐量。在异步编程中,我们可以并发执行多个异步任务,从而提高程序的并发性和性能。在异步编程中,我们可以将回调函数注册到异步任务上,当任务完成时,事件循环会自动调用相应的回调函数,从而处理任务的结果。异步编程能够提高程序的响应速度,

m0_70911440的博客 1254

从入门到精通:Python asyncio异步编程核心组件实战(附代码解析 || 协程,任务,事件循环,Future)

本文深入解析Python asyncio异步编程的核心组件,包括协程、任务、事件循环和Future,并通过实战代码演示如何构建高效异步网络爬虫。文章详细介绍了异步编程的关键概念和最佳实践,帮助开发者从入门到精通掌握Python异步编程技术,提升I/O密集型任务的执行效率。

weixin_29288313的博客 250

【AI实战派】从零部署YOLOv8:香橙派AIpro边缘端目标检测全流程解析

本文详细解析了在香橙派AIpro边缘设备上从零部署YOLOv8目标检测模型的全流程。内容涵盖硬件开箱、环境搭建、模型转换(ONNX到昇腾OM格式)以及编写Python推理脚本,并提供了性能优化与实战技巧,帮助开发者高效实现实时边缘AI应用。

weixin_29183637的博客 333

手把手教你用NetToPLCsim搭建西门子S7-1200仿真环境(附避坑指南)

本文详细指导如何利用NetToPLCsim与PLCSIM搭建西门子S7-1200仿真环境,实现无硬件条件下的PLC程序测试与上位机通信开发。内容涵盖软件选型、环境部署、关键参数配置及通信测试,并重点提供了连接失败、数据读写错误等常见问题的深度避坑指南,帮助工程师高效构建可靠的虚拟调试工作流。

a3b4c5的博客 618

Python高级开发(十五):并发编程之asyncio核心原理剖析

本文深入解析Python asyncio框架的异步机制,揭示其单线程高并发的三大核心:事件循环作为中央调度器监控I/O和任务;协程通过async/await实现合作式多任务切换;Future/Task作为异步操作的占位符。通过代码示例演示了事件循环如何调度任务,并对比了顺序执行与并发执行的效率差异(3秒vs2秒)。文章指出理解这些底层原理对构建高性能异步应用至关重要,将asyncio比作由事件循环舞台、协程演员和Task导演组成的精密系统。

专注于网络安全攻防技术与安全运营(SecOps)实践。 985

汽车诊断服务(UDS——0x11服务解析)

ECU复位服务(0x11)详解:该服务支持硬件/钥匙开关/软件三种复位类型(0x01-0x03),复位前需发送肯定响应。请求格式为11+子功能,响应含51+子功能。典型应用需配合安全访问流程,测试时需监控CAN总线通信及DTC状态。复位后ECU将返回默认会话,期间不处理任何诊断请求。服务在编程会话且安全解锁后执行,硬复位会初始化存储数据。

从事汽车行业 980

Python中的异步编程从入门到精通的终极指南

异步编程是一种高效的编程范式,它允许程序在等待耗时操作(如I/O、网络请求)完成时,去执行其他任务,而不是傻等。这极大地提升了应用程序的性能和响应能力,特别是在处理大量并发连接时。在Python中,asyncio库是实现异步编程的核心,它提供了一个框架,使用async和await关键字来编写单线程并发代码。从使用定义协程,到利用事件循环和Task实现并发,再到掌握高级模式以避免常见陷阱,Python的异步编程提供了一条从入门到精通的清晰路径。核心在于理解其“在等待时做其他事”的非阻塞哲学。

qu2011的博客 299

MAX96712在车载摄像头系统中的带宽分配与传输能力计算解析

在计算摄像头带宽与传输接口的关系时,需要考虑视频流的像素分辨率、帧率、颜色深度等因素。以 MAX96712 这种 GMSL2 产品为例,它支持每个链路在正向方向以 3Gbps 或 6Gbps 的固定速率工作。

weixin_43199439的博客 3332

共聚焦显微镜的光源、工作原理与选型

共聚焦显微镜作为科研与工业领域中重要的微观成像工具,凭借光源的精准适配性、光学切片技术的三维成像能力,以及对不同工业场景的定制化适配潜力,为半导体检测、工业部件分析、智能制造升级提供了关键技术支撑。深入理解其光源特性、工作原理与选型逻辑,能帮助工程师与技术人员精准匹配设备与生产需求,既保障微观检测的精度与效率,又为产业优化、技术创新筑牢微观观测的基础。

PhotonixBay的博客 1540

Python异步编程从协程到高性能并发实战

task2 = asyncio.create_task(asyncio.sleep(0.5), name=短任务)task1 = asyncio.create_task(asyncio.sleep(1), name=长任务)task1 = asyncio.create_task(async_task(任务1, 2))task2 = asyncio.create_task(async_task(任务2, 1))task3 = asyncio.create_task(async_task(任务3, 3))

WHdHiLOe的博客 888

【查找单入口空闲区域】-python实现-附ChatGPT解析

时间限制:1s 空间限制: 256MB 限定语言:不限题目描述:给定一个 m x n 的矩阵,由若干字符X’和 O构成,"X表示该处已被占据,O表示该处空闲,请找到最大的单入口空闲区域。空闲区域是由连通的O组成的区域,位于边界的O可以构成入口,单入口空闲区域即有且只有一个位于边界的o作为入口的由连通的O组成的区域如果两个元素在水平或垂直方向相邻,则称它们是“连通”的。第一行输入为两个数字,第一个数字为行数m,第二个数字列数n,两个数字以空格分隔,1

sinat_29950703的博客 243

Python【3-3】异步编程终极指南:从协程到高并发实战,一文掌握高效并发核心

核心优势‌:高并发‌:单线程轻松应对数千并发连接。低延迟‌:I/O密集型任务延迟降低90%以上。适用场景‌:Web服务器(FastAPI、Sanic)爬虫与数据采集实时监控与消息系统通过本文的代码实践与理论解析,读者可快速掌握Python异步编程的精髓。建议在实际项目中从简单场景入手,逐步构建高并发服务。‌异步不是银弹‌,但在正确场景下,它能将性能提升一个数量级!最后01、案例项目上百个完整的案例项目(涵盖多个技术点)02、学习路线。

2501_92499985的博客 1034

【11】科曼医疗——科曼医疗 嵌入式--面试,校招,面试问答记录

科曼医疗嵌入式校招面试记录:3位面试官分别考察应用层技术、底层技术和HR面。技术问题涵盖C++特性(多态、虚函数、指针与引用区别)、内存管理(malloc与new对比)、嵌入式基础(51最小系统、IIC/SPI协议)及项目经验(智能黑板擦专利项目)。同时考察了Linux使用经验、STM32开发及嵌入式操作系统认知。最后环节应聘者询问了开发环境及面试流程。面试内容全面覆盖嵌入式开发核心知识点。

程序员,他们想的是什么?他们想的永远都是技术,他们崇尚的也永远都是技术。 1253

室内温度控制仿真(Simulink+PLC)

本篇博客将会带领大家解读Simulink自带的仿真模型(Thermal Model of a House),之后再讨论PLC控制系统控制环境温度的一些经验方法

RXXW_Dor的博客 3465

Python(3.4)Python异步编程终极指南:从协程到高并发实战,一文掌握高效并发核心

核心优势‌:高并发‌:单线程轻松应对数千并发连接。低延迟‌:I/O密集型任务延迟降低90%以上。适用场景‌:Web服务器(FastAPI、Sanic)爬虫与数据采集实时监控与消息系统通过本文的代码实践与理论解析,读者可快速掌握Python异步编程的精髓。建议在实际项目中从简单场景入手,逐步构建高并发服务。‌异步不是银弹‌,但在正确场景下,它能将性能提升一个数量级!

优快云博客专家,领域包括但不限于:AI、大数据、Python、架构师,有合作、课程、问题、疑惑请私信博主 1060

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

Python中的协程与异步编程:提升并发性能的利器

本文介绍了Python中协程与异步编程的概念、优势及实现方式。协程作为可暂停和恢复的特殊函数,配合asyncio模块能够有效处理I/O密集型任务,提高程序并发性能。文章详细讲解了async/await关键字的使用方法,展示了如何通过asyncio.gather()并发执行多个协程任务。此外,还以异步HTTP请求为例,说明aiohttp库的实际应用,并介绍了异步任务中的异常处理和取消机制。异步编程使开发者能充分利用系统资源,显著提升网络请求、文件操作等场景下的程序效率,是现代应用开发的重要技能。

2501_94187056的博客 1114

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

python异步编程 - 什么是协程

Python协程是一种轻量级的执行单元,可以暂停和恢复执行,由程序控制切换。相比进程/线程,协程资源开销极小,适合高并发I/O密集型任务。它解决了多线程性能瓶颈和回调地狱问题,通过async/await语法简化异步编程。协程是异步编程的基石,与事件循环配合实现高效并发。asyncio库利用事件循环调度协程,在单线程内实现高性能并发模型。

nvd11的专栏 674

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

Python开发从入门到精通:异步编程进阶与asyncio高级应用

本文介绍了Python异步编程的高级技巧与asyncio库的高级应用。主要内容包括:异步编程概念及其高性能、高并发优势;asyncio库在协程调度、任务管理、异步IO操作和并发控制方面的应用;两个实战案例展示:异步爬虫实现网页抓取与解析(使用aiohttp和BeautifulSoup),以及异步Web服务器开发(处理HTTP请求、文件读取和数据库操作)。通过代码示例详细演示了如何使用信号量进行并发控制,以及如何构建完整的异步应用程序。学习重点在于掌握协程调度、任务管理等核心概念,并能实际应用于项目开发中。

编程世界如山海,探索不止。 1万+

Python 协程应用 —— 异步编程与并发编程:本质区别与内在联系

异步编程与并发编程在Python协程模型中相辅相成:**异步解决非阻塞执行问题,并发解决多任务调度问题**。异步编程通过`async/await`实现非阻塞IO,避免资源闲置;并发编程通过事件循环调度多个协程任务,实现逻辑并行。在协程中,两者结合使用才能发挥最大效能,但需注意:1) 正确创建任务实现真正并发;2) 避免在协程中混用阻塞操作;3) CPU密集型任务应使用进程池。理解两者的区别与协同机制,是构建高性能Python应用的基础。

YAnt的博客 789

Python协程详解:从并发编程基础到高性能服务器开发

本文系统介绍了Python协程技术及其在高并发场景中的应用。主要内容包括: 并发编程基础:详细解析CPU、进程、线程和协程的关系,对比传统并发模型与协程的差异。 Python协程核心技术:从生成器到原生协程的演进过程,深入讲解async/await语法和asyncio事件循环机制。 实战应用:演示如何使用协程构建百万级并发Web服务,包括异步HTTP服务器开发、数据库操作和性能优化策略。 职业发展:提供Python异步编程学习路径和职业规划建议。 文章通过理论讲解与代码实践相结合的方式,帮助开发者掌握协程的

Terio的博客 1145

现代Python:异步编程与协程的深度解析

本文深入探讨Python异步编程技术,主要介绍了async/await语法、协程和事件循环机制。通过示例展示异步编程在I/O密集型任务中的应用优势,如并发HTTP请求、网络爬虫等场景。文章还阐述了异步编程的核心概念、错误处理方式,并分析了其在高并发处理中的性能优势,同时指出异步编程存在一定学习曲线,需要合理设计以确保可靠性。

2501_94188140的博客 1103

Python asyncio高性能异步编程 详解

最大的意义:通过一个线程利用其IO等待时间去做一些其他事情。

qq_38196449的博客 3496

Python Async 异步编程:解锁高效并发操作的新境界

异步编程是一种并发处理的方式,它允许程序在执行 I/O 操作时不阻塞其他任务的进行。Python 的asyncio模块是异步编程的核心工具,从基础认识开始。")# 运行异步程序在本文中,分享了 Python 中的异步编程,这是应对大规模并发操作和提高程序性能的一项强大工具。通过asyncio模块,学习了异步 I/O 操作、协程、任务以及异步并发的核心概念。通过具体的示例代码,得以深入理解异步编程的工作原理和应用场景。

涛哥聊Python 1189
上一篇: Rust性能优化:从代码优化到底层调优
下一篇: Python数据库连接池:从原理到生产环境实践
第一程序员
博客等级 码龄1年 1万+粉丝 1827原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值