पायथन लाइब्रेरी में '_thread' मॉड्यूल हल्के वजन वाली प्रक्रियाओं के साथ काम करने के लिए एक निम्न-स्तरीय इंटरफ़ेस प्रदान करता है जिसमें वैश्विक डेटा स्थान साझा करने वाले एकाधिक थ्रेड होते हैं। सिंक्रोनाइज़ेशन के लिए, इस मॉड्यूल में साधारण ताले (जिसे म्यूटेक्स या बाइनरी सेमाफोर भी कहा जाता है) को परिभाषित किया गया है। 'थ्रेडिंग' बिल्ट-इन मॉड्यूल इस मॉड्यूल के शीर्ष पर निर्मित एक उच्च-स्तरीय थ्रेडिंग एपीआई प्रदान करता है।
start_new_thread()
इस मॉड्यूल-स्तरीय फ़ंक्शन का उपयोग वर्तमान प्रक्रिया में एक नया थ्रेड खोलने के लिए किया जाता है। फ़ंक्शन फ़ंक्शन ऑब्जेक्ट को तर्क के रूप में लेता है। यह फ़ंक्शन नए धागे के सफल निर्माण पर लागू होता है। इस फ़ंक्शन की अवधि धागे के जीवन काल से मेल खाती है। स्लीप () फ़ंक्शन को कॉल करके थ्रेड को ब्लॉक किया जा सकता है।
निम्नलिखित कोड _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() फ़ंक्शन एक नया थ्रेड उत्पन्न करता है जो रन फ़ंक्शन को समानांतर रूप से कॉल करता है। रन () फ़ंक्शन के साथ-साथ प्रोग्राम के मुख्य थ्रेड में एक लूप होता है। कॉल टू स्लीप () दोनों परिणाम ओवरलैप किए गए निष्पादन में कार्य करते हैं जैसा कि नीचे दिखाया गया है:-
main 1 child 1 main 2 child 2 main 3 child 3 main 4 child 4 main 5 child 5
लॉक ऑब्जेक्ट का उपयोग करके इंटर-थ्रेड सिंक्रोनाइज़ेशन प्राप्त किया जाता है। आबंटन_लॉक () फ़ंक्शन लॉक ऑब्जेक्ट देता है। इसके लिए निम्नलिखित तरीके उपलब्ध हैं
अधिग्रहण ()
यह विधि बिना शर्त ताला प्राप्त करती है जब तक कि इसे किसी अन्य थ्रेड द्वारा जारी नहीं किया जाता है। एक समय में केवल एक धागा ही ताला प्राप्त कर सकता है। यदि लॉक सफलतापूर्वक प्राप्त किया जाता है, तो वापसी मान सही है, यदि नहीं तो गलत है।
रिलीज ()
यह विधि ताला मुक्त करती है। ताला पहले हासिल किया जाना चाहिए था, लेकिन जरूरी नहीं कि उसी धागे से।
निम्नलिखित उदाहरण में, दो धागे घोषित किए गए हैं। प्रत्येक आह्वान रन () समवर्ती रूप से कार्य करता है। उनमें से एक लॉक प्राप्त कर लेता है और 'सिंक्रनाइज़्ड' फ़ंक्शन में प्रवेश करने के लिए आगे बढ़ता है जबकि अन्य प्रतीक्षा करता है।
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