पायथन में मल्टीथ्रेडेड क्यू कैसे इम्प्लीमेंट करें

परिचय

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

क्यू क्या है?

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

मान लीजिए आप किसी किराने की दुकान के काउंटर पर बिल चुकाने के लिए लाइन में खड़े हैं।

लोगों की लाइन में आप निम्नलिखित देखेंगे:

1. लोग लाइन के एक छोर से प्रवेश करते हैं और दूसरे छोर से निकलते हैं।
2. अगर व्यक्ति A, व्यक्ति B से पहले लाइन में आता है, तो व्यक्ति A, व्यक्ति B से पहले लाइन छोड़ेगा (जब तक कि व्यक्ति B सेलिब्रिटी न हो या उसे अधिक प्राथमिकता प्राप्त न हो)।
3. जब सभी बिल चुका देते हैं, तो लाइन में कोई नहीं बचता।

प्रोग्रामिंग में भी क्यू इसी तरह काम करती है:

1. enqueue - तत्व क्यू के अंत में जोड़े जाते हैं।
2. dequeue - तत्व क्यू की शुरुआत से हटाए जाते हैं।

इसके अलावा, दो प्रमुख सिद्धांत हैं:

• FIFO (First In First Out) - पहले जोड़ा गया तत्व पहले निकलेगा।
• LIFO (Last In First Out) - अंत में जोड़ा गया तत्व पहले निकलेगा।

पायथन में क्यू डेटा संरचना कैसे इम्प्लीमेंट की जाती है?

पायथन का queue मॉड्यूल क्यू डेटा संरचना का सरल इम्प्लीमेंटेशन प्रदान करता है। प्रत्येक क्यू में निम्नलिखित मेथड्स हो सकते हैं:

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

उदाहरण: मल्टीथ्रेडेड क्यू इम्प्लीमेंटेशन

हम एक फंक्शन बनाएंगे जो एक आर्गुमेंट x लेता है और 1 से x तक की संख्याओं के माध्यम से पुनरावृति करके गुणा करता है।

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]

अब 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)

एक क्लास बनाते हैं, जब एक नया इंस्टेंस आरंभ और शुरू किया जाता है, तो 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}")

अंत में, इनपुट सूची पास करके क्यू भरते हैं:

import queue
import threading
import time

input_values = [2, 4, 6, 5, 10, 3]
my_queue = queue.Queue()
for x in input_values:
    my_queue.put(x)

# 4 थ्रेड्स आरंभ और शुरू करना
thread1 = MultiThread('First')
thread2 = MultiThread('Second')
thread3 = MultiThread('Third')
thread4 = MultiThread('Fourth')

# थ्रेड्स शुरू करना
thread1.start()
thread2.start()
thread3.start()
thread4.start()

# थ्रेड्स जॉइन करना
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

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

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