python async异步编程详解|极客教程

python async异步编程详解

什么是异步编程

在传统的同步编程中，程序的执行是按照顺序依次进行的，每一步操作都要等待上一步操作完成之后才能执行。而在异步编程中，程序的执行不再是顺序执行，而是根据事件驱动的方式进行的，可以在等待某些耗时操作（如文件读写、网络请求等）的同时继续执行其他操作，从而提高程序的运行效率和性能。

Python的异步编程通过asyncio库来实现。asyncio是Python的标准库，提供了基于协程的异步编程功能，可以实现非阻塞的并发操作。在异步编程中，我们使用async/await关键字来定义异步函数和协程，通过事件循环来调度和执行异步任务。

异步编程的优势

异步编程具有以下优势：

提高程序的运行效率和性能：异步编程可以在等待耗时操作的同时继续执行其他操作，从而减少程序的等待时间，提高程序的并发性和性能。
改善用户体验：通过异步编程可以实现非阻塞的用户界面，提高用户体验，避免在等待网络请求或其他操作时出现界面卡顿的情况。
简化代码逻辑：异步编程可以使代码更加简洁、清晰，避免回调地狱和复杂的多线程并发处理。

asyncio库的基本用法

下面我们来看一些基本的asyncio库的用法：

定义异步函数

我们可以使用async/await关键字来定义异步函数，异步函数是一种特殊的函数，可以通过await关键字来挂起函数的执行，等待异步操作完成后再继续执行。

import asyncio

async def my_async_func():
    print("Start async function")
    await asyncio.sleep(2)
    print("End async function")

创建事件循环

在异步编程中，需要创建一个事件循环来调度和执行异步任务。我们可以使用asyncio库中的get_event_loop()方法来创建事件循环。

loop = asyncio.get_event_loop()

运行异步任务

我们可以使用事件循环的run_until_complete()方法来运行异步任务，让事件循环开始执行异步函数。

loop.run_until_complete(my_async_func())

完整示例

下面是一个完整的异步编程示例：

import asyncio

async def my_async_func():
    print("Start async function")
    await asyncio.sleep(2)
    print("End async function")

loop = asyncio.get_event_loop()
loop.run_until_complete(my_async_func())

运行结果如下：

Start async function
End async function

异步编程中的协程

在asyncio库中，主要使用协程来实现异步编程。协程是一种轻量级的线程，可以在事件循环中并发执行多个协程，实现真正的并发操作。

创建协程

我们可以使用async def关键字来定义一个协程，协程可以调用其他协程或异步函数。

async def my_coroutine():
    print("Start coroutine")
    await asyncio.sleep(1)
    print("End coroutine")

调度和执行协程

我们可以使用asyncio.create_task()方法来创建一个任务并将协程添加到事件循环中执行。

task = asyncio.create_task(my_coroutine())

完整示例

下面是一个使用协程实现的异步编程示例：

import asyncio

async def my_coroutine():
    print("Start coroutine")
    await asyncio.sleep(1)
    print("End coroutine")

async def main():
    task1 = asyncio.create_task(my_coroutine())
    task2 = asyncio.create_task(my_coroutine())

    await task1
    await task2

asyncio.run(main())

运行结果如下：

Start coroutine
Start coroutine
End coroutine
End coroutine

异步编程中的并发操作

在异步编程中，我们可以实现多个异步任务的并发操作，提高程序的并发性和性能。

并发执行

我们可以通过创建多个任务并使用await关键字实现多个任务的并发执行。

task1 = asyncio.create_task(my_coroutine())
task2 = asyncio.create_task(my_coroutine())

await task1
await task2

并发限制

有时候我们需要限制并发执行的任务数量，可以使用asyncio.Semaphore来设置并发数目。

semaphore = asyncio.Semaphore(2)

async def my_coroutine():
    async with semaphore:
        print("Start coroutine")
        await asyncio.sleep(1)
        print("End coroutine")

完整示例

下面是一个实现并发限制的异步编程示例：

import asyncio

semaphore = asyncio.Semaphore(2)

async def my_coroutine():
    async with semaphore:
        print("Start coroutine")
        await asyncio.sleep(1)
        print("End coroutine")

async def main():
    tasks = [my_coroutine() for _ in range(5)]
    await asyncio.gather(*tasks)

asyncio.run(main())

运行结果如下：

Start coroutine
Start coroutine
End coroutine
End coroutine
Start coroutine
Start coroutine
End coroutine
End coroutine
Start coroutine
End coroutine

异步编程中的异常处理

在异步编程中，我们也需要对异常进行处理，避免出现程序崩溃的情况。

异常处理

我们可以使用try…except语句来捕获异步函数中的异常。

async def raise_error():
    raise Exception("An error occurred")

async def main():
    try:
        await raise_error()
    except Exception as e:
        print(f"Caught exception: {e}")

完整示例

下面是一个异常处理的异步编程示例：

import asyncio

async def raise_error():
    raise Exception("An error occurred")

async def main():
    try:
        await raise_error()
    except Exception as e:
        print(f"Caught exception: {e}")

asyncio.run(main())