【python】- 协程函数 asyncio

原创 已于 2025-02-20 16:57:59 修改 · 530 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python #开发语言

于 2025-02-17 09:19:13 首次发布

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言

提示：本文主要提到python中异步并发操作，关于Thread多线程同步并发见上文。

Python 中的协程函数也就是我们所说的异步编程，它允许你编写非阻塞的代码，特别适用于 I/O 密集型任务（如网络请求、文件读写等）。首先需要清楚的明白如下概念：

  1. 同步编程
    像我们正常定义的函数就是同步函数，它只能每个函数依次进行，假如某个函数遇到了阻塞，那么整个程序将会被堵塞住，影响执行效率。当然我们可以通过多线程的方式处理，多线程处理的函数也是同步函数，他们将会在同一时刻同步并发。
  2. 异步编程
    异步编程也就是我们今天说的协程，它是在一个单一线程里执行的。它的概念是同一个时间段完成多个任务（就像我们人类一样，需要执行吃饭任务，在点完外卖后，不会一直等待外卖，而是这个时间去打一把游戏，等外卖到了，再继续执行吃饭任务，显然这更加的合理。）这就是所谓的异步并发。

提示：以下是本篇文章正文内容，仅供学习参考

一、asyncio是什么？

asyncio 是 Python 标准库中的一个模块，用于编写异步 I/O 操作的代码。它基于事件循环（Event Loop）和协程（Coroutine），能够高效地处理 I/O 密集型任务（如网络请求、文件读写等），同时避免阻塞主线程。

二、使用步骤

1.引入库

代码如下（示例）：

import asyncio

2. 定义协程函数 async

代码如下（示例）：

import asyncio
import time


async def task_1():
    print("send a task1 request...")
    await asyncio.sleep(5)
    print("get responds")
    return "task1"


async def task_2():
    print("send a task2 request...")
    await asyncio.sleep(3)
    print("get responds")
    return "task2"


if __name__ == '__main__':
    t1 = task_1()
    t2 = task_2()
    print(f"t1: {t1}, t2: {t2}")

async 关键字定义的函数为协程函数，返回一个协程对象，执行结果打印如下，得到的t1和t2是协程对象，结果如下

在这里插入图片描述

3. 执行协程函数 await

await 关键字是用来执行协程函数对象的，await 会暂停执行当前协程直到等待的协程执行完毕，并且让出控制权给事件循环，见示例代码：

import asyncio
import time


async def task_1():
    print("send a task1 request...")
    await asyncio.sleep(2)
    print("get task1 responds")
    return "task1"


async def task_2():
    print("send a task2 request...")
    await asyncio.sleep(3)
    print("get task2 responds")
    return "task2"


def task3():
    print("running task 3")
    time.sleep(3)
    print("end task3")


async def _main():
    ret = await task_1()
    ret = await task_2()
    task3()


if __name__ == '__main__':
    start_ = time.perf_counter()
    asyncio.run(_main())
    end_ = time.perf_counter()
    print(f"total : {end_ - start_}")

执行结果如下：

在这里插入图片描述

从输出结果看任务是顺序执行，运行时间也是接近8 s，那是因为await 的作用是等待后面协程执行结束，在示例代码中task1()、task2() 依次执行，直到结束才会执行下一个，也就是说在此的任务是串行的，适合前后任务有依赖的场景。

获取你会感到疑惑，如果止步于此，为何要大费周章的引入异步函数呢，普通函数不是也是逐行执行吗？await 和普通函数的执行方式确实有一些相似之处，但它们的关键区别在于是否会阻塞事件循环，以及 是否允许并发执行其他任务。我们对上面代码做如下修改：

import asyncio
import time


async def task_1():
    print("send a task1 request...")
    await asyncio.sleep(2)
    print("get task1 responds")
    return "task1"


async def task_2():
    print("send a task2 request...")
    await asyncio.sleep(3)
    print("get task2 responds")
    return "task2"


def task3():
    print("running task 3")
    time.sleep(3)
    print("end task3")


async def _main():
    task1 = asyncio.create_task(task_1())
    task2 = asyncio.create_task(task_2())
    await task1
    await task2
    task3()


if __name__ == '__main__':
    start_ = time.perf_counter()
    asyncio.run(_main())
    end_ = time.perf_counter()
    print(f"total : {end_ - start_}")

运行结果如下：

在这里插入图片描述

可见运行时间变短了，因为task1和task2是异步并发的，代码中通过create_task方法创建任务，再用await关键字，task2并没有等待task1执行完毕再执行，两者是并发关系。

这里的执行顺序如下：

  1. 执行task1遇到await asyncio.sleep(2)，暂停执行, 把控制权给事件循环。
  2. 事件循环开始执行task2也遇到await asyncio.sleep(3), 暂停执行，交出控制权。
  3. 事件循环发现task1中await asyncio.sleep(2)结束了，恢复运行task1。
  4. 事件循环再恢复运行task2, 最后再正常等待两个任务执行完毕

所以如上场景适用于task1和task2没有依赖，做到了并发的操作，所以await的核心就是让出控制权给事件循环，让事件循环调度所有的协程函数。

注意：同样的我们还可以在task1中调用协程任务task4, task5, 同样遵循上面的规律串行或并行。对于task3，事件循环也会等待task1和task2执行完毕后再继续执行。

对于并行所有任务还有另外一种简单的写法，效果是一样的如下：

async def _main():
    await asyncio.gather(task_1(), task_2())
    task3()

4. 事件循环 （Event Loop）

事件循环（Event Loop） 是异步编程的核心机制，它负责调度和执行异步任务（如协程），并管理 I/O 操作、定时器、回调等。事件循环使得程序能够在等待 I/O 操作（如网络请求、文件读写）时不会阻塞，从而高效地处理并发任务。

事件循环主要作用是负责任务的调度，开启，停止，恢复，关闭，这些操作我们都可以通过asyncio.run(_main())，这里的_main是调度的函数。如上面的代码，就是通过这种方式创建事件循环的。

除了通过asyncio.run的方式自动创建和关闭事件循环，还可以手动创建事件循环，如下：

import asyncio


async def task1():
    print("Task 1 started")
    await asyncio.sleep(1)
    print("Task 1 finished")


async def task2():
    print("Task 2 started")
    await asyncio.sleep(2)
    print("Task 2 finished")


# 获取事件循环
loop = asyncio.get_event_loop()
try:
    # 运行任务
    loop.run_until_complete(task1())
    loop.run_until_complete(task2())
finally:
    loop.close()

稍加修改同步处理任务

import asyncio


async def task1():
    print("Task 1 started")
    await asyncio.sleep(1)
    print("Task 1 finished")


async def task2():
    print("Task 2 started")
    await asyncio.sleep(2)
    print("Task 2 finished")


# 获取事件循环
loop = asyncio.get_event_loop()
try:
    # 运行任务
    loop.run_until_complete(asyncio.gather(task1(), task2()))
finally:
    loop.close()

除了通过asyncio.run自动创建和关闭事件循环，还可以手动管理，代码如下：

import asyncio


async def task1():
    print("Task 1 started")
    await asyncio.sleep(1)
    print("Task 1 finished")


async def task2():
    print("Task 2 started")
    await asyncio.sleep(2)
    print("Task 2 finished")


# 创建事件循环
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
try:
    # 运行任务
    loop.run_until_complete(asyncio.gather(task1(), task2()))

finally:
    loop.close()

asyncio.new_event_loop() 创建一个事件循环，然后事件循环运行一个任务，最后关闭事件循环。当然还可以直接获得一个当前的事件循环，假如当前没有事件循环，就会自动创建，代码如下：

import asyncio


async def task1():
    print("Task 1 started")
    await asyncio.sleep(1)
    print("Task 1 finished")


async def task2():
    print("Task 2 started")
    await asyncio.sleep(2)
    print("Task 2 finished")


# 创建事件循环
loop = asyncio.get_event_loop()
try:
    # 运行任务
    loop.run_until_complete(asyncio.gather(task1(), task2()))

finally:
    loop.close()

注意： 通常一个线程里面只允许存在一个事件循环，假如存在多个事件循环运行，会抛出异常。

另外，在一个事件循环里面，开始运行了一个任务后，需要等待这个任务执行结束，才可以重新调用 loop.run_until_complete, 这个函数是不允许嵌套使用的，否则会出现loop is running 的错误信息，如下面代码：

import asyncio


async def task1():
    loop = asyncio.get_event_loop()

    async def task3():
        print("task3")
    task3 = loop.create_task(task3())
    loop.run_until_complete(task3)


async def task2():
    print("Task 2 started")
    await asyncio.sleep(2)
    print("Task 2 finished")


async def _main():
    await task1()
    await task2()


# 创建事件循环
if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    _main = loop.create_task(_main())
    loop.run_until_complete(_main)
    loop.close()

输出报错信息：

在这里插入图片描述

5. 多线程中使用协程 run_coroutine_threadsafe()

前面说了，协程是为单线程服务的，每一个线程中只存在一个事件循环，当然也是可以在多线程里启动多个事件循环的，见如下代码：

import asyncio
import threading
import time


# 定义一个协程任务
async def task(name):
    print(f"{name} 开始")
    await asyncio.sleep(1)
    print(f"{name} 结束")


# 启动事件循环的函数
def start_loop(loop):
    asyncio.set_event_loop(loop)
    loop.run_forever()


# 创建两个事件循环
loop1 = asyncio.new_event_loop()
loop2 = asyncio.new_event_loop()

# 创建两个线程，每个线程运行一个事件循环
thread1 = threading.Thread(target=start_loop, args=(loop1,), daemon=True)
thread2 = threading.Thread(target=start_loop, args=(loop2,), daemon=True)

# 启动线程
thread1.start()
thread2.start()

# 在主线程中调度任务到不同线程的事件循环
asyncio.run_coroutine_threadsafe(task("任务 1"), loop1)
asyncio.run_coroutine_threadsafe(task("任务 2"), loop2)

# 主线程等待一段时间，确保子线程中的任务完成
time.sleep(3)

上面代码在主线程里创建两个事件循环，然后创建两个守护线程，然后再把任务通过run_coroutine_threadsafe()执行，注意事件循环会一直运行，但是由于守护线程的因素，当程序运行结束，整个线程退出。

我们也可以接收run_coroutine_threadsafe()的返回对象，获取任务运行结果。

import asyncio
import threading

async def task(name, delay):
    return f"{name} 结果"

def start_loop(loop):
    asyncio.set_event_loop(loop)
    loop.run_forever()

# 创建事件循环并启动线程
loop = asyncio.new_event_loop()
thread = threading.Thread(target=start_loop, args=(loop,), daemon=True)
thread.start()

# 调度任务并获取结果
future = asyncio.run_coroutine_threadsafe(task("任务 1", 1), loop)
print(future.result())  # 阻塞等待任务完成并获取结果

注意：这里的future.result()方法是阻塞的，只有当结果返回后程序才会结束，这也保证了线程安全的执行完。

另外还可以通过future.done()判断任务执行状态，代码如下：

# 调度任务并获取结果
future = asyncio.run_coroutine_threadsafe(task("任务 1", 1), loop)
while not future.done():
    print("任务正在执行")
print(future.result())  # 阻塞等待任务完成并获取结果

还可以调用强行停止事件循环方法call_soon_threadsafe，此时不管协程是否执行结束，事件循环都会被关闭：

import asyncio
import threading
import time


async def task(name, delay):
    print(f"{name} 开始")
    await asyncio.sleep(delay)
    print(f"{name} 结束")

def start_loop(loop):
    asyncio.set_event_loop(loop)
    loop.run_forever()

# 创建事件循环并启动线程
loop = asyncio.new_event_loop()
thread = threading.Thread(target=start_loop, args=(loop,))
thread.start()

# 调度任务
asyncio.run_coroutine_threadsafe(task("任务 1", 3), loop)

time.sleep(5)
# 停止事件循环
loop.call_soon_threadsafe(loop.stop)

# 等待线程结束
thread.join()

总结

以上就是今天要讲的内容，本文介绍了协程函数和事件循环的使用，对于绝大部分场合，使用ayncio.run()管理事件循环是最好的选择。

大执
关注
python协程—asyncio模块
这家伙很懒，什么都没有留下
07-04 1104
协程是一种并发编程的技术，通过允许程序在执行过程中暂停和恢复，实现了高效利用资源、简化异步编程逻辑、提高代码可读性和可维护性、并发性能提升等优势。主要应用场景包括异步编程、事件驱动编程和并发任务调度等。
Python通过协程实现异步爬虫--asyncio技巧
景天科技苑
12-29 4771
很多同学对于异步这个概念只是停留在了“听说很NB”的认知层面上，很少有人能够在项目中真正的使用异步实现高性能的相关操作。接下来，咱们就一起来学习一下，爬虫中如何使用异步实现高性能的数据爬取操作。
Python asyncio 模块
xiaoaque的博客
07-02 857
asyncio是 Python 标准库中的一个模块，用于编写异步 I/O 操作的代码。asyncio 提供了一种高效的方式来处理并发任务，特别适用于 I/O 密集型操作，如网络请求、文件读写等。通过使用asyncio，你可以在单线程中同时处理多个任务，而无需使用多线程或多进程。
python之协程
Good Luck
09-15 2037
这可供长期间运行的函数使用以避免在函数调用的全过程中阻塞事件循环。如果一个协程在等待一个 Future 对象，Task 对象会挂起该协程的执行并等待该 Future 对象完成。未在其他地方被引用的任务可能在任何时候被作为垃圾回收，即使是在它被完成之前。可以等待返回的每个协程，以从剩余的可迭代对象中获得最早的下一个结果。允许在不同的线程中访问来自事件循环的上下文变量。更强的安全保证：如果一个任务（或子任务，即由一个任务调度的任务）引发了异常，的方便可靠方式的任务创建 API。在超时发生时不会取消可等待对象。
Python 异步：asyncio 基础使用指南
最新发布
2501_93878977的博客
10-31 270
【Python】asyncio
宅男很神经
07-10 600
在本章中，我们将深入探究Python生成器的最底层机制。我们将从迭代器协议的本质出发，逐步揭示关键字的魔力，以及它如何将一个普通函数转化为拥有暂停与恢复能力的生成器。此外，我们还将覆盖生成器表达式的简洁性与效率，并详细剖析生成器高级控制方法，如、和，理解它们在构建复杂控制流中的关键作用。在Python中，迭代是一个核心概念。它允许我们遍历集合中的元素，无论是列表、元组、字符串还是其他更复杂的数据结构。实现这种遍历行为的背后，是Python的迭代协议（Iteration Protocol）。理解这个协议是理解
python asyncio_Python 的异步 IO：Asyncio 简介
weixin_39652760的博客
11-23 182
所谓「异步 IO」，就是你发起一个 IO 操作，却不用等它结束，你可以继续做其他事情，当它结束时，你会得到通知。Asyncio 是并发（concurrency）的一种方式。对 Python 来说，并发还可以通过线程（threading）和多进程（multiprocessing）来实现。Asyncio 并不能带来真正的并行（parallelism）。当然，因为 GIL（全局解释器锁）的存在，Pyth...
Python协程函数
dianyi3179的博客
04-13 178
1 协程函数 1.1 协程函数理解 协程函数就是使用了yield表达式形式的生成器 def eater(name): print("%s eat food" %name) while True: food = yield print("done") g = eater("gangdan") print(g) 结果: generator ob...
Python3.6-asyncio-协程入门
qq_42794720的博客
05-10 1994
Python3.6-asyncio-协程入门
WebScrapper-using-python-asyncio
03-14
"WebScrapper-using-python-asyncio-master" 文件夹可能包含以下结构： 1. `scraper.py`：包含主要的爬虫代码，使用 asyncio 实现异步请求。 2. `config.py`：配置文件，可能包含了请求头、超时设置、重试策略等。 3...
Python 协程-asyncio、async/await
ShanSan
03-13 1120
看到吐血(´ཀ`」 ∠)more。
python asyncio (协程、异步编程)
I_AM_MD的博客
12-14 7529
asyncio （Asynchronous I/O）模块是一个异步代码库，它提供了一种基于协程（coroutine）和事件循环（event loop）的编程模型。是很多python异步架构的基础，多用于处理高并发网络请求方面的问题
Python的协程异步IO（asyncio）详解
热门推荐
创作不易，请多支持，将为本站提供更多「有价值的文章」。
09-19 1万+
协程不是系统级线程，很多时候协程被称为“轻量级线程”、“微线程”、“纤程(fiber)”等。简单来说可以认为协程是线程里不同的函数，这些函数之间可以相互快速切换。协程和用户态线程非常接近，用户态线程之间的切换不需要陷入内核，但部分操作系统中用户态线程的切换需要内核态线程的辅助。协程是编程语言（或者 lib）提供的特性（协程之间的切换方式与过程可以由编程人员确定），是用户态操作。协程适用于 IO 密集型的任务。
Python标准模块--asyncio
weixin_34162695的博客
11-20 257
1 模块简介 asyncio模块作为一个临时的库，在Python 3.4版本中加入。这意味着，asyncio模块可能做不到向后兼容甚至在后续的Python版本中被删除。根据Python官方文档，asyncio通过coroutines、sockets和其它资源上的多路复用IO访问、运行网络客户端和服务端以及其它相关的原始服务等提供了一种单线程并发应用的架构。本文并不能覆盖所有关于asyncio模块的...
python asyncio
qq_26847293的博客
03-12 860
asyncio是Python 3.4版本引入的标准库，直接内置了对异步IO的支持。 asyncio的编程模型就是一个消息循环。我们从asyncio模块中直接获取一个EventLoop的引用，然后把需要执行的协程扔到EventLoop中执行，就实现了异步IO。用asyncio实现Hello world代码如下：import asyncio@asyncio.coroutine def hello():
Python异步编程框架—asyncio
m0_75067629的博客
03-28 1560
Python 的异步编程框架 asyncio 是 Python 3.4 引入的一个重要模块，它为开发者提供了编写并发代码的能力，尤其适合处理 I/O 密集型任务（如网络请求、文件 I/O 等）。
4.2 协程：asyncio实现协程
人生是一场修行
12-25 1491
注意：所谓的回调函数，就是指协程函数coroutine执行结束时候会调用回调函数。并通过参数future获取协程执行的结果。我们创建的task和回调里的future对象，实际上是同一个对象，因为task是future的子类。
Python的Asyncio模块
m0_62943934的博客
07-02 1194
Task 继承 Future，Task对象内部 await 结果的处理是基于 Future 对象来的。await + 可等待的对象（协程对象、future 对象、Task 对象 -> IO 等待）官网解释：“Future” 是一种特殊的低级可等待对象，它表示异步操作的最终结果。，fastAPI、Django 快的原因，比 js 事件循环快，小于 go。的方式创建Task对象，这样可以让协程加入事件循环中等待被调度执行。事件循环的替代方案，第三方方案，在一定程度上提高事件循环的效率。
Python 异步asyncio学习篇（转）
Songsong
07-25 1万+
原标题：Python异步编程模块asyncio学习 asyncio是Python3.4引入的一个标准库，直接内置了对异步IO的支持。asyncio模块提供了使用协程构建并发应用的工具。它使用一种单线程单进程的的方式实现并发，应用的各个部分彼此合作, 可以显示的切换任务，一般会在程序阻塞I/O操作的时候发生上下文切换如等待读写文件,或者请求网络...
3、python-协程是什么、协程和线程的区别
07-26
### 协程的概念 Python 协程是一种轻量级的并发编程模型，它允许函数在执行过程中暂停并保存当前状态，以便稍后从暂停的位置继续执行。这种特性使得协程非常适合处理高并发和 I/O 密集型任务，因为它们能够在单线程中通过非阻塞的方式进行任务调度，减少了线程上下文切换的开销，从而更有效地利用计算资源 [^1]。 在 Python 中，协程通常通过 `async def` 定义，并使用 `await` 表达式来挂起和恢复执行。例如： ```python async def my_coroutine(): print("Coroutine started") await asyncio.sleep(1) print("Coroutine finished") ``` ### 协程与线程的区别 #### 1. **实现方式** - **线程**：线程是操作系统级别的并发机制，每个线程都有自己的栈空间和寄存器状态，线程之间的切换由操作系统调度器负责。线程的创建和销毁成本较高，且线程间的上下文切换会带来一定的开销 [^2]。 - **协程**：协程是用户级别的并发机制，它们的调度完全由程序控制，而不是操作系统。协程的切换不需要操作系统介入，因此切换成本更低，创建和销毁的开销也较小 [^3]。 #### 2. **资源占用** - **线程**：由于线程是由操作系统管理的，每个线程都需要分配一定的内存空间（如栈空间），这使得线程的资源占用相对较大。当线程数量较多时，可能会导致内存不足的问题 [^2]。 - **协程**：协程的资源占用非常小，通常只需要几百字节的内存。这使得在同一时间内可以创建成千上万个协程而不会消耗过多的系统资源 [^1]。 #### 3. **并发模型** - **线程**：线程的并发模型基于抢占式调度，操作系统会根据优先级和时间片来决定哪个线程获得 CPU 时间。这种模型可能导致竞态条件和死锁等问题，需要通过锁机制来保证线程安全 。 - **协程**：协程的并发模型基于协作式调度，协程之间的切换是由程序显式控制的。这意味着协程在同一时刻只有一个在运行，避免了多线程中的竞态条件问题，简化了并发编程的复杂性 [^3]。 #### 4. **适用场景** - **线程**：线程适用于需要充分利用多核处理器的 CPU 密集型任务。由于线程可以并行执行，因此在处理计算密集型任务时，线程可以提供更好的性能 [^2]。 - **协程**：协程更适合处理 I/O 密集型任务，如网络请求、文件读写等。在这种场景下，协程可以通过异步 I/O 操作来避免阻塞，从而提高程序的整体吞吐量 [^1]。 #### 5. **编程模型** - **线程**：线程的编程模型较为复杂，需要处理线程同步、资源共享等问题。Python 中的 `threading` 模块提供了线程的支持，但由于全局解释器锁（GIL）的存在，Python 的多线程并不能真正实现并行执行 [^2]。 - **协程**：协程的编程模型相对简单，主要依赖于 `asyncio` 库提供的事件循环和异步 I/O 操作。通过 `async/await` 语法，开发者可以更容易地编写异步代码 。 ### 总结 Python 协程是一种轻量级的并发编程模型，它通过协作式调度和用户级别的上下文切换，减少了线程上下文切换的开销，从而更有效地利用计算资源。与线程相比，协程的资源占用更小，适合处理 I/O 密集型任务，而线程更适合处理 CPU 密集型任务。理解它们的关系与差异有助于在实际应用中选择合适的并发模型 [^1]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值