पाइथन के साथ मल्टीथ्रेडेड कतार को कैसे कार्यान्वित करें

परिचय..

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

हम इस सवाल से शुरू करेंगे कि कतार क्या है? एक क्यू एक डेटा संरचना है जो एक बहुत ही विशिष्ट क्रम में बनाए गए विभिन्न तत्वों का संग्रह है। मुझे वास्तविक जीवन का उदाहरण लेते हुए समझाएं।

मान लें कि आप किराने की दुकान के काउंटर पर अपने किराना बिल का भुगतान करने के लिए कतार में खड़े हैं, (मुझसे कौन सी किराने की दुकान पूछें)

अपने बिलों का भुगतान करने की प्रतीक्षा कर रहे लोगों की कतार में, आप निम्नलिखित को नोटिस करेंगे:

1. लोग लाइन के एक छोर से प्रवेश करते हैं और दूसरे छोर से बाहर निकलते हैं।

2. यदि व्यक्ति A व्यक्ति B से पहले पंक्ति में प्रवेश करता है, तो व्यक्ति A व्यक्ति B से पहले पंक्ति को छोड़ देगा (जब तक कि व्यक्ति B एक प्रसिद्ध व्यक्ति नहीं है या उसकी प्राथमिकता अधिक है)।

3. एक बार जब सभी ने अपने बिलों का भुगतान कर दिया, तो लाइन में कोई नहीं बचेगा।

खैर, प्रोग्रामिंग पर वापस जाएं जहां एक क्यू एक समान तरीके से काम करता है।

1. एनक्यू - कतार के अंत में जोड़े गए तत्व।

2. dequeue - कतार की शुरुआत से हटाए गए तत्व।

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

पायथन कतार डेटा संरचना को कैसे कार्यान्वित करता है?

पायथन में कतार मॉड्यूल कतार डेटा संरचना का एक सरल कार्यान्वयन प्रदान करता है। प्रत्येक कतार में निम्नलिखित विधियाँ हो सकती हैं।

get ():अगला तत्व लौटाता है।
put():एक नया तत्व जोड़ता है।
qsize ():कतार में मौजूदा तत्वों की संख्या।
खाली ():एक बूलियन लौटाता है, यह दर्शाता है कि कतार खाली है या नहीं।
पूर्ण ():एक बूलियन लौटाता है, यह दर्शाता है कि कतार भरी हुई है या नहीं।

1. हम एक फ़ंक्शन बनाएंगे जो एक तर्क x लेता है, फिर गुणन करने के लिए 1 और स्वयं (x) के बीच की संख्याओं के माध्यम से पुनरावृत्त होता है। उदाहरण के लिए जब आप इस फ़ंक्शन में 5 पास करते हैं तो यह 1 से 5 तक पुनरावृत्त होता है और गुणा करता रहता है अर्थात 1 गुना 5, 2 गुना 5, 3 गुना 5, 4 गुना 5, 5 गुना 5 अंत में एक सूची के रूप में मान लौटाता है।

उदाहरण

def print_multiply(x):
output_value = []
for i in range(1, x + 1):
output_value.append(i * x)
print(f"Output \n *** The multiplication result for the {x} is - {output_value}")
print_multiply(5)

आउटपुट

*** The multiplication result for the 5 is - [5, 10, 15, 20, 25]

2. हम process_queue() नामक एक और फ़ंक्शन लिखेंगे जो कतार वस्तु के अगले तत्व को प्राप्त करने का प्रयास करेगा। इसके लिए तर्क काफी सरल है, तत्वों को तब तक पास करते रहें जब तक कि कतार खाली न हो जाए। मैं थोड़ा आगे बढ़ने में देरी करने के लिए नींद का उपयोग करूंगा।

उदाहरण

def process_queue():
while True:
try:
value = my_queue.get(block=False)
except queue.Empty:
return
else:
print_multiply(value)
time.sleep(2)

3. एक क्लास बनाएं, जब कोई नया इंस्टेंस इनिशियलाइज़ और शुरू होता है, तो process_queue() फंक्शन को कॉल किया जाएगा।

उदाहरण

class MultiThread(threading.Thread):
def __init__(self, name):
threading.Thread.__init__(self)
self.name = name

def run(self):
print(f" ** Starting the thread - {self.name}")
process_queue()
print(f" ** Completed the thread - {self.name}")

4. अंत में, हम संख्याओं की इनपुट सूची पास करेंगे और कतार भरेंगे।

# setting up variables
input_values = [5, 10, 15, 20]

# fill the queue
my_queue = queue.Queue()
for x in input_values:
my_queue.put(x)

5. अंत में, सभी को एक साथ रखकर।

import queue
import threading
import time

# Class
class MultiThread(threading.Thread):
def __init__(self, name):
threading.Thread.__init__(self)
self.name = name

def run(self):
print(f"Output \n ** Starting the thread - {self.name}")
process_queue()
print(f" ** Completed the thread - {self.name}")

# Process thr queue
def process_queue():
while True:
try:
value = my_queue.get(block=False)
except queue.Empty:
return
else:
print_multiply(value)
time.sleep(2)

# function to multiply
def print_multiply(x):
output_value = []
for i in range(1, x + 1):
output_value.append(i * x)
print(f" \n *** The multiplication result for the {x} is - {output_value}")

# Input variables
input_values = [2, 4, 6, 5,10,3]

# fill the queue
my_queue = queue.Queue()
for x in input_values:
my_queue.put(x)
# initializing and starting 3 threads
thread1 = MultiThread('First')
thread2 = MultiThread('Second')
thread3 = MultiThread('Third')
thread4 = MultiThread('Fourth')

# Start the threads
thread1.start()
thread2.start()
thread3.start()
thread4.start()

# Join the threads
thread1.join()
thread2.join()
thread3.join()
thread4.join()

आउटपुट

** Starting the thread - First
*** The multiplication result for the 2 is - [2, 4]

आउटपुट

** Starting the thread - Second
*** The multiplication result for the 4 is - [4, 8, 12, 16]

आउटपुट

** Starting the thread - Third
*** The multiplication result for the 6 is - [6, 12, 18, 24, 30, 36]

आउटपुट

** Starting the thread - Fourth
*** The multiplication result for the 5 is - [5, 10, 15, 20, 25]
*** The multiplication result for the 10 is - [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
*** The multiplication result for the 3 is - [3, 6, 9] ** Completed the thread - Third
** Completed the thread - Fourth
** Completed the thread - Second ** Completed the thread - First

6. हमने कतार अवधारणा को सफलतापूर्वक लागू किया है। देखिए, हमारे पास 4 थ्रेड हैं लेकिन प्रोसेस करने के लिए 6 मान हैं, इसलिए जो भी कतार में सबसे पहले आएगा उसे निष्पादित किया जाएगा और अन्य लोग लाइन में होंगे और दूसरों के पूरा होने की प्रतीक्षा करेंगे।

यह एक वास्तविक जीवन के समान है, मान लें कि 3 काउंटर हैं लेकिन 10 लोग अपने बिलों का भुगतान करने की प्रतीक्षा कर रहे हैं, इसलिए 10 लोग 3 कतारों में होंगे और जिन्होंने बिलों का भुगतान पूरा कर लिया है, वे लाइन छोड़कर अगले व्यक्ति के लिए रास्ता बनाएंगे।