पायथन लाइब्रेरी में '_thread' मॉड्यूल ग्लोबल डेटा स्पेस शेयर करने वाले लाइट-वेट प्रोसेसेस (मल्टीपल थ्रेड्स) के साथ काम करने के लिए लो-लेवल इंटरफ़ेस प्रदान करता है। सिंक्रोनाइज़ेशन के लिए, इस मॉड्यूल में सिंपल लॉक्स (जिन्हें म्यूटेक्स या बाइनरी सेमाफोर भी कहा जाता है) परिभाषित हैं। 'threading' बिल्ट-इन मॉड्यूल इस मॉड्यूल के ऊपर बना एक हायर-लेवल थ्रेडिंग API प्रदान करता है।
start_new_thread()
यह मॉड्यूल-लेवल फ़ंक्शन करंट प्रोसेस में एक नया थ्रेड खोलने के लिए उपयोग किया जाता है। फ़ंक्शन एक फ़ंक्शन ऑब्जेक्ट को तर्क के रूप में लेता है। नए थ्रेड के सफल निर्माण पर इस फ़ंक्शन को आमंत्रित किया जाता है। इस फ़ंक्शन का जीवनकाल थ्रेड के जीवनकाल से मेल खाता है। थ्रेड को sleep() फ़ंक्शन कॉल करके ब्लॉक किया जा सकता है।
_thread मॉड्यूल का उपयोग करके थ्रेड मैकेनिज़्म का एक सरल उदाहरण निम्न है:
import _thread
import time
def run(threadName):
count = 0
for i in range(1, 6):
time.sleep(5)
print(threadName, i)
_thread.start_new_thread(run, ("child",))
for i in range(1, 6):
print('main', i)
time.sleep(5)
start_new_thread() फ़ंक्शन एक नया थ्रेड स्पॉन करता है जो run फ़ंक्शन को समानांतर रूप से कॉल करता है। run() फ़ंक्शन में और प्रोग्राम के मुख्य थ्रेड दोनों में एक लूप है। दोनों में sleep() फ़ंक्शन की कॉल के परिणामस्वरूप ओवरलैप्ड एक्ज़ीक्यूशन होता है:
main 1 child 1 main 2 child 2 main 3 child 3 main 4 child 4 main 5 child 5
इंटर-थ्रेड सिंक्रोनाइज़ेशन
इंटर-थ्रेड सिंक्रोनाइज़ेशन Lock ऑब्जेक्ट का उपयोग करके प्राप्त किया जाता है। allocate_lock() फ़ंक्शन लॉक ऑब्जेक्ट लौटाता है। इसके लिए निम्न मेथड्स उपलब्ध हैं:
acquire()
यह मेथड लॉक को बिना शर्त तब तक प्राप्त करता है जब तक इसे दूसरे थ्रेड द्वारा रिलीज़ नहीं किया जाता। एक समय में केवल एक थ्रेड ही लॉक प्राप्त कर सकता है। रिटर्न मान True होता है यदि लॉक सफलतापूर्वक प्राप्त हो जाता है, अन्यथा False।
release()
यह मेथड लॉक को रिलीज़ करता है। लॉक पहले प्राप्त किया हुआ होना चाहिए, लेकिन जरूरी नहीं कि उसी थ्रेड द्वारा।
निम्न उदाहरण में, दो थ्रेड घोषित किए गए हैं। प्रत्येक run() फ़ंक्शन को समवर्ती रूप से आमंत्रित करता है। उनमें से एक लॉक प्राप्त करता है और 'सिंक्रोनाइज़्ड' फ़ंक्शन में प्रवेश करता है जबकि दूसरा प्रतीक्षा करता है।
import _thread
import time
def run(threadName):
lock.acquire()
synchronized(threadName)
lock.release()
def synchronized(threadName):
print(threadName, "has acquired lock")
counter = 10
while counter:
time.sleep(1)
print('*', end='')
counter = counter - 1
print('\n{} has released lock'.format(threadName))
lock = _thread.allocate_lock()
_thread.start_new_thread(run, ("t1",))
_thread.start_new_thread(run, ("t2",))
आउटपुट
>>> t1 has acquired lock ********** t1 has released lock t2 has acquired lock ********** t2 has released lock
