परिचय

पायथन में थ्रेडिंग मॉड्यूल थ्रेड बनाने और प्रबंधित करने के लिए एक उच्च-स्तरीय इंटरफ़ेस प्रदान करता है, जो आपको कोड को समवर्ती रूप से चलाने में सक्षम बनाता है। यह उन कार्यों के लिए विशेष रूप से उपयोगी हो सकता है जिन्हें समानांतर में निष्पादित किया जा सकता है, जैसे कि I/O-बाउंड ऑपरेशन। नीचे संक्षिप्त उदाहरणों के साथ थ्रेडिंग मॉड्यूल में आमतौर पर उपयोग की जाने वाली विधियों और कार्यों की एक सूची दी गई है।

1. धागा()

थ्रेड क्लास थ्रेडिंग मॉड्यूल का दिल है। आप इस क्लास का उपयोग करके नए थ्रेड बना और शुरू कर सकते हैं।

import threading

def print_numbers():
    for i in range(5):
        print(i)

t = threading.Thread(target=print_numbers)
t.start()  # Starts a new thread
t.join()   # Waits for the thread to finish

2. प्रारंभ()

थ्रेड की गतिविधि प्रारंभ करता है।

t = threading.Thread(target=print_numbers)
t.start()  # Runs the target function in a separate thread

3. शामिल हों([समयबाह्य])

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

t = threading.Thread(target=print_numbers)
t.start()
t.join(2)  # Waits up to 2 seconds for the thread to finish

4. जीवित है()

यदि थ्रेड अभी भी चल रहा है तो यह सत्य लौटाता है।

t = threading.Thread(target=print_numbers)
t.start()
print(t.is_alive())  # True if the thread is still running

5. करंट_थ्रेड()

कॉलिंग थ्रेड का प्रतिनिधित्व करते हुए वर्तमान थ्रेड ऑब्जेक्ट लौटाता है।

import threading

def print_current_thread():
    print(threading.current_thread())

t = threading.Thread(target=print_current_thread)
t.start()  # Prints the current thread info

6. गणना करें()

वर्तमान में जीवित सभी थ्रेड ऑब्जेक्ट्स की एक सूची लौटाता है।

t1 = threading.Thread(target=print_numbers)
t2 = threading.Thread(target=print_numbers)
t1.start()
t2.start()

print(threading.enumerate())  # Lists all active threads

7. सक्रिय_गणना()

वर्तमान में जीवित थ्रेड ऑब्जेक्ट की संख्या लौटाता है।

print(threading.active_count())  # Returns the number of active threads

8. लॉक()

लॉक ऑब्जेक्ट एक आदिम लॉक है जिसका उपयोग दौड़ की स्थिति को रोकने के लिए किया जाता है। आप इसका उपयोग यह सुनिश्चित करने के लिए कर सकते हैं कि एक समय में केवल एक थ्रेड ही साझा संसाधन तक पहुंच सके।

lock = threading.Lock()

def thread_safe_function():
    with lock:  # Acquires the lock
        # Critical section
        print("Thread-safe code")

t = threading.Thread(target=thread_safe_function)
t.start()

9. आरलॉक()

एक रीएंट्रेंट लॉक एक थ्रेड को स्वयं को अवरुद्ध किए बिना कई बार लॉक प्राप्त करने की अनुमति देता है।

lock = threading.RLock()

def reentrant_function():
    with lock:
        with lock:  # Same thread can acquire the lock again
            print("Reentrant lock example")

t = threading.Thread(target=reentrant_function)
t.start()

10. शर्त()

एक कंडीशन ऑब्जेक्ट थ्रेड्स को कुछ शर्तों के पूरा होने तक प्रतीक्षा करने की अनुमति देता है।

condition = threading.Condition()

def thread_wait():
    with condition:
        condition.wait()  # Wait for the condition
        print("Condition met")

def thread_notify():
    with condition:
        condition.notify()  # Notify the waiting thread

t1 = threading.Thread(target=thread_wait)
t2 = threading.Thread(target=thread_notify)
t1.start()
t2.start()

11. घटना()

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

event = threading.Event()

def wait_for_event():
    event.wait()  # Wait until the event is set
    print("Event has been set")

t = threading.Thread(target=wait_for_event)
t.start()
event.set()  # Set the event to allow the thread to continue

12. सेमाफोर()

एक सेमाफोर ऑब्जेक्ट आपको उन थ्रेड्स की संख्या को सीमित करने की अनुमति देता है जो एक संसाधन तक एक साथ पहुंच सकते हैं।

semaphore = threading.Semaphore(2)  # Only 2 threads can access the resource at once

def access_resource():
    with semaphore:
        print("Resource accessed")

t1 = threading.Thread(target=access_resource)
t2 = threading.Thread(target=access_resource)
t3 = threading.Thread(target=access_resource)

t1.start()
t2.start()
t3.start()

13. टाइमर (अंतराल, फ़ंक्शन)

एक टाइमर थ्रेड एक निर्दिष्ट अंतराल के बाद एक फ़ंक्शन निष्पादित करता है।

def delayed_function():
    print("Executed after delay")

timer = threading.Timer(3, delayed_function)
timer.start()  # Executes `delayed_function` after 3 seconds

14. सेटडेमन(सत्य)

डेमॉन थ्रेड पृष्ठभूमि में चलते हैं और मुख्य प्रोग्राम के बाहर निकलने पर स्वचालित रूप से बाहर निकल जाते हैं। आप setDaemon(True) को कॉल करके या थ्रेड कंस्ट्रक्टर को daemon=True पास करके किसी थ्रेड को डेमॉन बना सकते हैं।

t = threading.Thread(target=print_numbers, daemon=True)
t.start()  # Daemon thread will exit when the main program ends

निष्कर्ष

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