Python 3.7

Queues




python

Queues

asyncio कतार queue मॉड्यूल के वर्गों के समान डिज़ाइन की गई हैं। यद्यपि एसिंको की कतारें थ्रेड-सेफ नहीं हैं, लेकिन उन्हें विशेष रूप से एसिंक्स / वेट कोड में उपयोग करने के लिए डिज़ाइन किया गया है।

ध्यान दें कि asyncio कतारों के तरीकों में टाइमआउट पैरामीटर नहीं है; asyncio.wait_for() फ़ंक्शन का उपयोग टाइमआउट के साथ कतार संचालन करने के लिए करें।

नीचे दिए गए Examples अनुभाग भी देखें।

पंक्ति

class asyncio.Queue(maxsize=0, *, loop=None)

ए फर्स्ट इन, फर्स्ट आउट (एफआईएफओ) कतार।

यदि अधिकतम आकार शून्य से कम या इसके बराबर है, तो कतार का आकार अनंत है। यदि यह 0 से अधिक पूर्णांक है, तो await put() ब्लॉक तब मिलता है जब कतार अधिकतम हो जाती है जब तक कि किसी आइटम को हटा नहीं दिया जाता get()

मानक लाइब्रेरी थ्रेडिंग queue विपरीत, queue का आकार हमेशा ज्ञात होता है और इसे qsize() विधि कहकर लौटाया जा सकता है।

यह वर्ग धागा सुरक्षित नहीं है

maxsize

कतार में अनुमत वस्तुओं की संख्या।

empty()

यदि कतार खाली है, तो True लौटें अन्यथा False

full()

यदि कतार में maxsize आइटम हैं तो True लौटें।

यदि कतार को maxsize=0 (डिफ़ॉल्ट) के साथ आरंभ किया गया था, तो full() कभी भी True नहीं है।

coroutine get()

किसी आइटम को कतार से निकालें और वापस करें। यदि कतार खाली है, तो एक आइटम उपलब्ध होने तक प्रतीक्षा करें।

get_nowait()

यदि कोई वस्तु तत्काल उपलब्ध हो, तो उसे QueueEmpty , अन्यथा QueueEmpty

coroutine join()

तब तक रोकें जब तक कतार में सभी आइटम प्राप्त और संसाधित नहीं हो जाते।

जब भी कोई आइटम कतार में जोड़ा जाता है तो अधूरे कार्यों की गिनती बढ़ जाती है। जब भी कोई उपभोक्ता task_done() को इंगित करने के लिए कहता है कि आइटम को पुनर्प्राप्त किया गया था और उस पर सभी काम पूरा हो गया है तो गिनती नीचे जाती है। जब अधूरे कामों की गिनती शून्य हो जाती है, तो join() अनब्लॉक करें।

coroutine put(item)

किसी वस्तु को कतार में रखें। यदि कतार भरी हुई है, तो आइटम जोड़ने से पहले एक मुफ्त स्लॉट उपलब्ध होने तक प्रतीक्षा करें।

put_nowait(item)

किसी वस्तु को बिना रुके कतार में लगाएं।

यदि कोई मुफ्त स्लॉट तुरंत उपलब्ध नहीं है, तो QueueFull

qsize()

कतार में वस्तुओं की संख्या लौटाएं।

task_done()

इंगित करें कि पूर्व में संलग्न कार्य पूर्ण है।

कतार उपभोक्ताओं द्वारा उपयोग किया जाता है। कार्य प्राप्त करने के लिए उपयोग किए जाने वाले प्रत्येक get() लिए, बाद में task_done() को कॉल कतार को बताती है कि कार्य पूरा हो गया है।

यदि कोई task_done() वर्तमान में अवरुद्ध हो रहा है, तो यह तब शुरू होगा जब सभी आइटम संसाधित हो गए होंगे (इसका अर्थ है कि प्रत्येक आइटम के लिए एक task_done() कॉल प्राप्त हुआ था जिसे कतार में put() गया था)।

अगर क़तार में रखी गई वस्तुओं की तुलना में अधिक बार कॉल किया जाता है, तो ValueError

प्राथमिकता कतार

class asyncio.PriorityQueue

Queue का एक प्रकार; प्राथमिकता क्रम में प्रविष्टियाँ पुनर्प्राप्त करता है (सबसे पहले)।

प्रविष्टियां आमतौर पर फॉर्म (priority_number, data) टुपल्स हैं।

LIFO कतार

class asyncio.LifoQueue

Queue का एक प्रकार जो सबसे हाल ही में जोड़ी गई प्रविष्टियों को पहले (आखिरी में, पहले बाहर) को पुनः प्राप्त करता है।

अपवाद

exception asyncio.QueueEmpty

यह अपवाद तब उठाया जाता है जब get_nowait() विधि को खाली कतार में कहा जाता है।

exception asyncio.QueueFull

अपवाद को तब उठाया जाता है जब put_nowait() विधि को एक कतार पर बुलाया जाता है जो इसके put_nowait() तक पहुंच गया है।

उदाहरण

कई समवर्ती कार्यों के बीच कार्यभार वितरित करने के लिए कतारों का उपयोग किया जा सकता है:

import asyncio
import random
import time


async def worker(name, queue):
    while True:
        # Get a "work item" out of the queue.
        sleep_for = await queue.get()

        # Sleep for the "sleep_for" seconds.
        await asyncio.sleep(sleep_for)

        # Notify the queue that the "work item" has been processed.
        queue.task_done()

        print(f'{name} has slept for {sleep_for:.2f} seconds')


async def main():
    # Create a queue that we will use to store our "workload".
    queue = asyncio.Queue()

    # Generate random timings and put them into the queue.
    total_sleep_time = 0
    for _ in range(20):
        sleep_for = random.uniform(0.05, 1.0)
        total_sleep_time += sleep_for
        queue.put_nowait(sleep_for)

    # Create three worker tasks to process the queue concurrently.
    tasks = []
    for i in range(3):
        task = asyncio.create_task(worker(f'worker-{i}', queue))
        tasks.append(task)

    # Wait until the queue is fully processed.
    started_at = time.monotonic()
    await queue.join()
    total_slept_for = time.monotonic() - started_at

    # Cancel our worker tasks.
    for task in tasks:
        task.cancel()
    # Wait until all worker tasks are cancelled.
    await asyncio.gather(*tasks, return_exceptions=True)

    print('====')
    print(f'3 workers slept in parallel for {total_slept_for:.2f} seconds')
    print(f'total expected sleep time: {total_sleep_time:.2f} seconds')


asyncio.run(main())