Asyncio Queue

最新推荐文章于 2024-05-04 21:17:37 发布
转载 最新推荐文章于 2024-05-04 21:17:37 发布 · 506 阅读 · 2 ·
CC 4.0 BY-SA版权
原文链接：https://tutorialedge.net/python/concurrency/asyncio-synchronization-primitives-tutorial/

本文探讨了异步编程在Python中的实现，通过使用asyncio库创建了一个简单的生产者-消费者模型，展示了如何利用事件循环进行高效的任务调度。在jupyter环境中，特别介绍了nest_asyncio的使用，以解决事件循环的兼容性问题。

新的启动事件循环

import asyncio
import random
import time
import logging
from contextlib import closing

import nest_asyncio

nest_asyncio.apply( )  # 在jupyter需要这个，不然asyncio运行出错
logging.basicConfig(  # 用日志打印输出信息
    level = logging.INFO,
    format = "%(asctime)s %(process)d %(thread)d [*] %(message)s"
)


async def newsProducer(myQueue):
    while True:
        await asyncio.sleep(1)
        data = random.randint(1, 5)
        logging.info(f"将产品放入队列{data}")
        await myQueue.put(data)


async def newsConsumer(id, myQueue):
    while True:
        logging.info("消费者: {} 试图从队列中获取".format(id))
        item = await myQueue.get( )
        if item is None:
            break
        logging.info("消费者: {} 消耗了ID的商品: {}".format(id, item))


async def main( ):
    myQueue = asyncio.Queue(maxsize = 10)
    await asyncio.gather(
        newsProducer(myQueue),
        newsConsumer("A", myQueue),
        newsConsumer("B", myQueue),
    )


if __name__ == "__main__":
    # 修改了这里
    with closing(asyncio.get_event_loop( )) as loop:
        loop.run_until_complete(main( ))

旧的启动事件循环

import asyncio
import random
import time
import logging
import nest_asyncio
nest_asyncio.apply() # 在jupyter需要这个，不然asyncio运行出错
logging.basicConfig(  # 用日志打印输出信息
    level=logging.INFO,
    format="%(asctime)s %(process)d %(thread)d [*] %(message)s"
)


async def newsProducer(myQueue):
    while True:
        await asyncio.sleep(1)
        data = random.randint(1, 5)
        logging.info(f"将产品放入队列{data}")
        await myQueue.put(data)


async def newsConsumer(id, myQueue):
    while True:
        logging.info("消费者: {} 试图从队列中获取".format(id))
        item = await myQueue.get()
        if item is None:
            break
        logging.info("消费者: {} 消耗了ID的商品: {}".format(id, item))

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    myQueue = asyncio.Queue(loop=loop, maxsize=10)
    try:
        loop.run_until_complete(asyncio.gather(
            newsProducer(myQueue),
            newsConsumer("A", myQueue),
            newsConsumer("B", myQueue),
        ))
    except KeyboardInterrupt:
        asyncio.Task.all_tasks()
        asyncio.gather(*asyncio.Task.all_tasks()).cancel()
        loop.stop()
        # loop.run_forever()  # 在jupyter不能手动关闭
    finally:
        pass
        # loop.close()  # 在jupyter不能手动关闭






    2019-11-15 16:01:57,574 10912 13460 [*] 消费者: A 试图从队列中获取
    2019-11-15 16:01:57,592 10912 13460 [*] 消费者: B 试图从队列中获取
    2019-11-15 16:01:58,577 10912 13460 [*] 将产品放入队列1
    2019-11-15 16:01:58,584 10912 13460 [*] 消费者: A 消耗了ID的商品: 1
    2019-11-15 16:01:58,589 10912 13460 [*] 消费者: A 试图从队列中获取
    2019-11-15 16:01:59,580 10912 13460 [*] 将产品放入队列4
    2019-11-15 16:01:59,585 10912 13460 [*] 消费者: B 消耗了ID的商品: 4
    2019-11-15 16:01:59,590 10912 13460 [*] 消费者: B 试图从队列中获取
    2019-11-15 16:02:00,598 10912 13460 [*] 将产品放入队列1
    2019-11-15 16:02:00,604 10912 13460 [*] 消费者: A 消耗了ID的商品: 1
    2019-11-15 16:02:00,609 10912 13460 [*] 消费者: A 试图从队列中获取
    2019-11-15 16:02:01,602 10912 13460 [*] 将产品放入队列2
    2019-11-15 16:02:01,610 10912 13460 [*] 消费者: B 消耗了ID的商品: 2
    2019-11-15 16:02:01,618 10912 13460 [*] 消费者: B 试图从队列中获取
    2019-11-15 16:02:02,609 10912 13460 [*] 将产品放入队列2
    2019-11-15 16:02:02,619 10912 13460 [*] 消费者: A 消耗了ID的商品: 2
    2019-11-15 16:02:02,626 10912 13460 [*] 消费者: A 试图从队列中获取
    2019-11-15 16:02:03,618 10912 13460 [*] 将产品放入队列1
    2019-11-15 16:02:03,626 10912 13460 [*] 消费者: B 消耗了ID的商品: 1
    2019-11-15 16:02:03,631 10912 13460 [*] 消费者: B 试图从队列中获取
    2019-11-15 16:02:04,622 10912 13460 [*] 将产品放入队列5
    2019-11-15 16:02:04,628 10912 13460 [*] 消费者: A 消耗了ID的商品: 5
    2019-11-15 16:02:04,632 10912 13460 [*] 消费者: A 试图从队列中获取
    2019-11-15 16:02:05,623 10912 13460 [*] 将产品放入队列3
    2019-11-15 16:02:05,631 10912 13460 [*] 消费者: B 消耗了ID的商品: 3
    2019-11-15 16:02:05,634 10912 13460 [*] 消费者: B 试图从队列中获取
Python 异步编程：使用 `asyncio.to_thread` 和 `asyncio.Queue` 处理任务队列
engchina的专栏
10-24 2926
Python 异步编程：使用 `asyncio.to_thread` 和 `asyncio.Queue` 处理任务队列
asyncio之asyncio.Queue 任务队列 生产者-消费者流
weixin_41970297的博客
03-22 1058
asyncio.Queue 示例 import asyncio, random urls = '''http://m.sohu.com http://jd.com http://qq.com http://sohu.com http://bilibili.com http://sina.com.cn http://youku.com''' urls = urls.split('\n') # 包工头 给工人发布任务 async def producer(queue): while True:
python中利用队列asyncio.Queue进行通讯详解
09-21
asyncio是Python 3.4版本引入的标准库,直接内置了对异步IO的支持。 下面这篇文章主要给大家介绍了关于python中利用队列asyncio.Queue进行通讯的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考下。
asyncio 队列(Queue)
迷心兔的博客
10-09 2331
# coding=utf-8 import asyncio import random import aiohttp NUMBERS = random.sample(range(100), 7) URL = 'http://httpbin.org/get?a={}' semaphore = asyncio.Semaphore(3) async def fetch_async (a): ...
asyncio queue
weixin_30399797的博客
12-12 148
from asyncio import Queue,sleep import asyncio from threading import Thread import time qu=Queue() #put async def putQ(): global qu print('start put') i=1 while True: ...
在 Python 异步协程中使用同步队列
luhanhua的专栏
05-04 1666
下面，我们用程序实例来说明这个问题。虽然表面上看，它是在一个异步任务中进行的，但实际上它阻塞的不仅仅是这个异步任务，而是包括所有任务的整个线程，tsk1 和 tsk2 的执行被阻塞，直到 tsk3 收到队列消息，将 running_flag 置为 False，tsk1 和 tsk2 随即退出，后面的打印自然就无法进行了。在并发的异步程序中，发生这类问题的原因往往是错用了同步程序中有关阻塞的操作，例如，在该用 asynio.sleep 的地方错用了 time.sleep，也会引起整个线程中并发协程的阻塞。
Python之asyncio.Queue
qiuqiuit的专栏
02-07 9726
asyncio.Queue一个队列，规则是先进先出，先存入先取出。 官方文档上有个例子： https://asyncio.readthedocs.io/en/latest/producer_consumer.html 代码如下： import asyncio import random async def produce(queue, n): for x in range(n)...
Python异步请求：使用asyncio.Queue进行任务调度
Jamson
08-01 1979
是一个基于异步编程的FIFO队列实现。它是协程安全的，可以用于在不同的协程之间发送和接收数据，实现协程之间的通信和协作。
python asyncio queue
Cocktail_py的博客
09-17 1761
asyncio 队列被设计成与 queue 模块类似。尽管asyncio队列不是线程安全的，但是他们是被设计专用于async/await 代码。 注意asyncio 的队列没有timeout 形参 import asyncio, random, time async def rnd_sleep(t): # sleep for T seconds on average awai...
详解python异步编程之asyncio(百万并发)
12-25
前言：python由于GIL（全局锁）的存在，不能发挥多核的优势，其性能一直饱受诟病。然而在IO密集型的网络编程里，异步处理比同步处理能提升成百上千倍的效率，弥补了python性能方面的短板，如最新的微服务框架japronto，resquests per second可达百万级。 python还有一个优势是库（第三方库）极为丰富，运用十分方便。asyncio是python3.4版本引入到标准库，python2x没有加这个库，毕竟python3x才是未来啊，哈哈！python3.5又加入了async/await特性。 在学习asyncio之前，我们先来理清楚同步/异步的概念： 同步是指完成
python asyncio queue_python异步编程模块asyncio学习(二)
weixin_39559079的博客
12-09 572
尽管asyncio应用通常作为单线程运行，不过仍被构建为并发应用。由于I/O以及其他外部事件的延迟和中断，每个协程或任务可能按一种不可预知的顺序执行。为了支持安全的并发执行，asyncio包含了threading和multiprocessing模块中的一些底层原语的实现。锁(LOCK)锁可以用来保护对一个共享资源的访问。只有锁的持有者可以使用这个资源。如果有多个请求要的到这个锁，那么其将会阻塞，以...
asyncio 系列三、asyncio 队列
duxin_csdn的博客
05-24 4218
asyncio 队列 classasyncio.Queue(maxsize=0,*,loop=None) 先进，先出（FIFO）队列 如果maxsize小于等于零，则队列尺寸是无限的。如果是大于0的整数，则当队列达到maxsize时，awaitput()将阻塞至某个元素被get()取出。 不像标准库中的并发型queue，队列的尺寸一直是已知的，可以通过调用...
简析Python中的四种队列
python学习者的博客
05-21 7374
队列是一种只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 在Python文档中搜索队列（queue）会发现，Python标准库中包含了四种队列，分别是queue.Queue / asyncio.Queue / multiprocessing.Queue / collections.deque。 collections.deque deque是双端队列（double-ended q...
python 中 asyncio.Queue 的使用
08-25 2967
从队列中获取元素 使用get()方法可以从队列中获取元素。get()方法将会返回队列中的一个元素，并将其从队列中移除。向队列中放入元素 使用put()方法可以向队列中放入元素。异步操作 asyncio.Queue是基于协程的异步编程库asyncio的一部分，因此可以在异步程序中使用await关键字来等待队列中的元素。Python的asyncio.Queue是一个用于多任务协作的队列对象，它是基于协程的异步编程库asyncio的一部分。队列的大小 使用qsize()方法可以返回队列中当前的元素个数。
python asyncio queue_Python 3.7 通过 asyncio 实现异步编程
weixin_39618176的博客
12-09 585
Python 中通过 asyncio 实现的异步编程主要包含如下三个模块：事件循环(event loop)：每一个需要异步执行的任务都会在事件循环中注册，事件循环负责管理这些任务之间的执行流程协程(Coroutine)：指用于执行具体某个异步任务的函数。函数体中的 await 关键字可以将协程的控制权释放给事件循环Future：表示已经执行或者尚未执行的任务的结果在异步程序的世界里，所有代码都运行...
python里使用队列asyncio.Queue进行通讯
热门推荐
大坡3D软件开发
09-09 1万+
asyncio.Queue与其它队列是一样的，都是先进先出，它是为协程定义的，例子如下：import asyncio async def consumer(n, q): print('consumer {}: starting'.format(n)) while True: print('consumer {}: waiting for item'.format
asyncio.Queue()
最新发布
04-11
### Python `asyncio.Queue` 使用方法及示例 #### 什么是 `asyncio.Queue` `asyncio.Queue` 是 Python 的异步编程库 `asyncio` 提供的一个队列实现，用于在协程之间传递数据。它支持常见的队列操作，例如放入 (`put`) 和获取 (`get`) 数据项，并且这些操作都是异步的，可以在等待时释放事件循环。 #### 基本属性和方法 以下是 `asyncio.Queue` 的一些常用属性和方法[^2]: - **maxsize**: 队列的最大大小，默认为 0 表示无限制。 - **empty()**: 如果队列为空，则返回 True。 - **full()**: 如果队列为满，则返回 True。 - **get()**: 获取并移除队列中的一个项目，如果队列为空则会挂起直到有可用的数据。 - **put(item)**: 将一个项目放入队列中，如果队列已满则会挂起直到有足够的空间。 - **task_done()**: 表明之前入队的任务已完成处理。 - **join()**: 阻塞调用者，直到队列中的所有任务都完成。 #### 示例代码 下面是一个简单的生产者消费者模式的例子，展示了如何使用 `asyncio.Queue`: ```python import asyncio async def producer(queue): for i in range(5): # 生产 5 个项目 print(f'Producer is producing item {i}') await queue.put(i) # 放入队列 await asyncio.sleep(1) async def consumer(queue): while True: item = await queue.get() # 从队列获取项目 if item is None: # 结束信号 break print(f'Consumer consumed item {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() # 等待所有任务完成 # 发送结束信号给消费者 await queue.put(None) await consumer_task # 运行主函数 asyncio.run(main()) ``` 在这个例子中： - `producer` 协程负责向队列中添加数据。 - `consumer` 协程负责从队列中取出数据并消费它们。 - 主函数通过创建两个任务来运行这两个协程，并确保所有的生产和消费完成后才退出程序。 #### 注意事项 当使用 `asyncio.Queue` 时需要注意以下几点: - 当多个协程尝试访问同一个队列时，`asyncio.Queue` 自动管理同步问题。 - 可以设置最大容量 (maxsize)，防止内存占用过多。 - 应该始终调用 `queue.task_done()` 来表明一项工作已经完成，这有助于配合 `queue.join()` 正确控制流程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值