Python 3.7 - queue

कतार - एक सिंक्रनाइज़ कतार वर्ग




python

कतार - एक सिंक्रनाइज़ कतार वर्ग

स्रोत कोड: Lib/queue.py

queue मॉड्यूल बहु-निर्माता, बहु-उपभोक्ता कतार को लागू करता है। यह थ्रेडेड प्रोग्रामिंग में विशेष रूप से उपयोगी है जब जानकारी को कई थ्रेड्स के बीच सुरक्षित रूप से आदान-प्रदान किया जाना चाहिए। इस मॉड्यूल में Queue वर्ग सभी आवश्यक लॉकिंग शब्दार्थों को लागू करता है। यह पायथन में धागा समर्थन की उपलब्धता पर निर्भर करता है; threading मॉड्यूल देखें।

मॉड्यूल तीन प्रकार की कतार को लागू करता है, जो केवल उसी क्रम में भिन्न होता है जिसमें प्रविष्टियां पुनर्प्राप्त की जाती हैं। FIFO कतार में, पहले जोड़े गए कार्यों को पहले पुनर्प्राप्त किया जाता है। एक LIFO कतार में, सबसे हाल ही में जोड़ी गई प्रविष्टि पहली पुनर्प्राप्त (स्टैक की तरह संचालन) है। प्राथमिकता कतार के साथ, प्रविष्टियाँ क्रमबद्ध रखी जाती हैं ( heapq मॉड्यूल का उपयोग करके) और सबसे कम मूल्य वाली प्रविष्टि को पहले पुनर्प्राप्त किया जाता है।

आंतरिक रूप से, उन तीन प्रकार की कतारें अस्थायी रूप से प्रतिस्पर्धी धागे को ब्लॉक करने के लिए ताले का उपयोग करती हैं; हालाँकि, वे एक धागे के भीतर reentrancy को संभालने के लिए डिज़ाइन नहीं किए गए हैं।

इसके अलावा, मॉड्यूल एक "सरल" फीफो कतार प्रकार लागू करता है जहां विशिष्ट कार्यान्वयन छोटी कार्यक्षमता के बदले अतिरिक्त गारंटी प्रदान कर सकते हैं।

queue मॉड्यूल निम्नलिखित वर्गों और अपवादों को परिभाषित करता है:

class queue.Queue(maxsize=0)

एक FIFO कतार के लिए निर्माता। maxsize एक पूर्णांक है जो उन मदों की संख्या पर ऊपरी सीमा निर्धारित करता है जिन्हें कतार में रखा जा सकता है। इस आकार तक पहुँच जाने के बाद, जब तक कतार से उपभोग की जाने वाली वस्तुओं का उपभोग नहीं किया जाता है, तब तक सम्मिलन अवरुद्ध हो जाएगा। यदि अधिकतम आकार शून्य से कम या इसके बराबर है, तो कतार का आकार अनंत है।

class queue.LifoQueue(maxsize=0)

एक LIFO कतार के लिए निर्माता। maxsize एक पूर्णांक है जो उन मदों की संख्या पर ऊपरी सीमा निर्धारित करता है जिन्हें कतार में रखा जा सकता है। इस आकार तक पहुँच जाने के बाद, जब तक कतार से उपभोग की जाने वाली वस्तुओं का उपभोग नहीं किया जाता है, तब तक सम्मिलन अवरुद्ध हो जाएगा। यदि अधिकतम आकार शून्य से कम या इसके बराबर है, तो कतार का आकार अनंत है।

class queue.PriorityQueue(maxsize=0)

एक प्राथमिकता कतार के लिए निर्माता। maxsize एक पूर्णांक है जो उन मदों की संख्या पर ऊपरी सीमा निर्धारित करता है जिन्हें कतार में रखा जा सकता है। इस आकार तक पहुँच जाने के बाद, जब तक कतार से उपभोग की जाने वाली वस्तुओं का उपभोग नहीं किया जाता है, तब तक सम्मिलन अवरुद्ध हो जाएगा। यदि अधिकतम आकार शून्य से कम या इसके बराबर है, तो कतार का आकार अनंत है।

सबसे कम मूल्य वाली प्रविष्टियों को पहले प्राप्त किया जाता है (सबसे मूल्यवान प्रविष्टि वह है जिसे sorted(list(entries))[0] द्वारा लौटाया जाता है sorted(list(entries))[0] )। प्रविष्टियों के लिए एक विशिष्ट पैटर्न फॉर्म में एक टपल है: (priority_number, data)

यदि डेटा तत्व तुलनीय नहीं हैं, तो डेटा को उस वर्ग में लपेटा जा सकता है जो डेटा आइटम की उपेक्षा करता है और केवल प्राथमिकता संख्या की तुलना करता है:

from dataclasses import dataclass, field
from typing import Any

@dataclass(order=True)
class PrioritizedItem:
    priority: int
    item: Any=field(compare=False)
class queue.SimpleQueue

एक अनबिके फीफो कतार के लिए कंस्ट्रक्टर। सरल कतारों में टास्क ट्रैकिंग जैसे उन्नत कार्यक्षमता की कमी होती है।

संस्करण 3.7 में नया।

exception queue.Empty

गैर-अवरोधक get() होने पर उठाए गए अपवाद get() (या get_nowait() ) को Queue ऑब्जेक्ट पर कहा जाता है जो खाली है।

exception queue.Full

गैर-ब्लॉकिंग put() (या put_nowait() ) को उठाया जाने वाला अपवाद एक Queue ऑब्जेक्ट पर कहा जाता है जो भरा हुआ है।

कतार की वस्तुएँ

कतार वस्तुएं ( Queue , LifoQueue , या PriorityQueue Queue ) नीचे वर्णित सार्वजनिक तरीके प्रदान करती हैं।

Queue.qsize()

कतार के अनुमानित आकार को वापस करें। ध्यान दें, qsize ()> 0 गारंटी नहीं देता है कि बाद में मिलने वाला () ब्लॉक नहीं होगा, न ही qsize () <अधिकतम गारंटी देता है कि डाल () ब्लॉक नहीं होगा।

Queue.empty()

यदि कतार खाली है, तो True लौटें अन्यथा False । यदि खाली () रिटर्न True है तो यह गारंटी नहीं देता है कि बाद में कॉल करने के लिए () ब्लॉक नहीं होगा। इसी तरह, अगर खाली () रिटर्न False है तो यह गारंटी नहीं देता है कि प्राप्त करने के लिए एक बाद में कॉल () ब्लॉक नहीं होगी।

Queue.full()

यदि कतार पूर्ण है, तो True लौटें अन्यथा False । यदि पूर्ण () रिटर्न True है तो यह गारंटी नहीं देता है कि प्राप्त करने के लिए एक बाद में कॉल () ब्लॉक नहीं होगी। इसी तरह, यदि पूर्ण () रिटर्न False है तो यह गारंटी नहीं देता है कि बाद में कॉल करने के लिए () ब्लॉक नहीं होगा।

Queue.put(item, block=True, timeout=None)

आइटम को कतार में रखें। यदि वैकल्पिक आर्ग्स ब्लॉक सही है और टाइमआउट None (डिफ़ॉल्ट), तो ब्लॉक करें यदि आवश्यक हो तो मुफ्त स्लॉट उपलब्ध होने तक। यदि टाइमआउट एक पॉजिटिव नंबर है, तो यह ज्यादातर टाइमआउट सेकंड में ब्लॉक हो जाता है और उस समय के भीतर कोई फ्री स्लॉट उपलब्ध नहीं होने पर Full अपवाद को उठाता है। अन्यथा ( ब्लॉक गलत है), एक आइटम को कतार पर रखें यदि एक मुफ्त स्लॉट तुरंत उपलब्ध है, तो Full अपवाद उठाएं (उस स्थिति में समय-सीमा की अनदेखी की जाती है)।

Queue.put_nowait(item)

put(item, False) बराबर put(item, False)

Queue.get(block=True, timeout=None)

किसी आइटम को कतार से निकालें और वापस करें। यदि वैकल्पिक आर्ग्स ब्लॉक सत्य है और टाइमआउट None (डिफ़ॉल्ट), तब तक ब्लॉक करें जब तक कि कोई वस्तु उपलब्ध न हो। यदि टाइमआउट एक सकारात्मक संख्या है, तो यह अधिकांश टाइमआउट सेकंड में ब्लॉक हो जाता है और उस समय के भीतर कोई भी वस्तु उपलब्ध न होने पर Empty अपवाद को उठाता है। अन्यथा ( ब्लॉक झूठा है), एक आइटम वापस करें यदि कोई तुरंत उपलब्ध है, अन्यथा Empty अपवाद को उठाएं (उस मामले में समय की अनदेखी की गई है)।

Queue.get_nowait()

get(False) करने के get(False) बराबर get(False)

ट्रैकिंग का समर्थन करने के लिए दो तरीकों की पेशकश की जाती है, चाहे एनकाउंटर किए गए कार्यों को डेमन उपभोक्ता थ्रेड्स द्वारा पूरी तरह से संसाधित किया गया हो।

Queue.task_done()

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

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

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

Queue.join()

तब तक जब तक कतार में सभी आइटम मिल नहीं गए और संसाधित नहीं किए गए।

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

पूरा होने के लिए बाधक कार्यों की प्रतीक्षा करने का उदाहरण:

def worker():
    while True:
        item = q.get()
        if item is None:
            break
        do_work(item)
        q.task_done()

q = queue.Queue()
threads = []
for i in range(num_worker_threads):
    t = threading.Thread(target=worker)
    t.start()
    threads.append(t)

for item in source():
    q.put(item)

# block until all tasks are done
q.join()

# stop workers
for i in range(num_worker_threads):
    q.put(None)
for t in threads:
    t.join()

SimpleQueue ऑब्जेक्ट

SimpleQueue ऑब्जेक्ट्स नीचे वर्णित सार्वजनिक तरीके प्रदान करते हैं।

SimpleQueue.qsize()

कतार के अनुमानित आकार को वापस करें। ध्यान दें, qsize ()> 0 गारंटी नहीं देता है कि बाद में प्राप्त () ब्लॉक नहीं होगा।

SimpleQueue.empty()

यदि कतार खाली है, तो True लौटें अन्यथा False । यदि खाली () रिटर्न False है, तो यह गारंटी नहीं देता है कि प्राप्त करने के लिए एक बाद में कॉल () ब्लॉक नहीं होगी।

SimpleQueue.put(item, block=True, timeout=None)

आइटम को कतार में रखें। विधि कभी भी ब्लॉक नहीं होती है और हमेशा सफल होती है (संभावित निम्न-स्तरीय त्रुटियों को छोड़कर जैसे कि मेमोरी को आवंटित करने में विफलता)। वैकल्पिक आर्ग्स ब्लॉक और टाइमआउट को अनदेखा किया जाता है और केवल put() के साथ संगतता के लिए प्रदान किया जाता है।

CPython कार्यान्वयन विवरण: इस पद्धति में C कार्यान्वयन है जो कि रीइन्त्रेंट है। यही है, एक put() या get() कॉल को एक और थ्रेड द्वारा कॉल किया जा सकता है put() उसी गति से कॉल को डेडलॉक किए बिना या कतार के अंदर आंतरिक स्थिति को दूषित कर सकते हैं। यह विध्वंसक जैसे __del__ विधियों या weakref कॉलबैक में उपयोग के लिए उपयुक्त बनाता है।

SimpleQueue.put_nowait(item)

put(item) करने के लिए बराबर put(item) , put_nowait() के साथ संगतता के लिए प्रदान किया put_nowait()

SimpleQueue.get(block=True, timeout=None)

किसी आइटम को कतार से निकालें और वापस करें। यदि वैकल्पिक आर्ग्स ब्लॉक सत्य है और टाइमआउट None (डिफ़ॉल्ट), तब तक ब्लॉक करें जब तक कि कोई वस्तु उपलब्ध न हो। यदि टाइमआउट एक सकारात्मक संख्या है, तो यह अधिकांश टाइमआउट सेकंड में ब्लॉक हो जाता है और उस समय के भीतर कोई भी वस्तु उपलब्ध न होने पर Empty अपवाद को उठाता है। अन्यथा ( ब्लॉक झूठा है), एक आइटम वापस करें यदि कोई तुरंत उपलब्ध है, अन्यथा Empty अपवाद को उठाएं (उस मामले में समय की अनदेखी की गई है)।

SimpleQueue.get_nowait()

get(False) करने के get(False) बराबर get(False)

यह भी देखें

Class multiprocessing.Queue
बहु-प्रसंस्करण (बहु-सूत्रण के बजाय) संदर्भ में उपयोग के लिए एक कतार वर्ग।

collections.deque तेजी से परमाणु append() और popleft() संचालन के साथ popleft() कतारों का एक वैकल्पिक कार्यान्वयन है जिसमें लॉकिंग की आवश्यकता नहीं होती है।