Python 3.7 - threading

थ्रेडिंग - थ्रेड-आधारित समानता




python

थ्रेडिंग - थ्रेड-आधारित समानता

स्रोत कोड: Lib/threading.py

यह मॉड्यूल निचले स्तर के _thread मॉड्यूल के शीर्ष पर उच्च-स्तरीय थ्रेडिंग इंटरफ़ेस का निर्माण करता है। queue मॉड्यूल भी देखें।

संस्करण 3.7 में परिवर्तित: यह मॉड्यूल वैकल्पिक हुआ करता था, यह अब हमेशा उपलब्ध है।

ध्यान दें

हालांकि उन्हें नीचे सूचीबद्ध नहीं किया गया है, इस मॉड्यूल में कुछ तरीकों और कार्यों के लिए उपयोग किए गए camelCase नाम पायथॉन 2.x श्रृंखला अभी भी इस मॉड्यूल द्वारा समर्थित हैं।

यह मॉड्यूल निम्नलिखित कार्यों को परिभाषित करता है:

threading.active_count()

वर्तमान में ज़िंदा Thread ऑब्जेक्ट्स की संख्या वापस करें। लौटी हुई enumerate() द्वारा लौटी सूची की लंबाई के बराबर है।

threading.current_thread()

नियंत्रण के कॉलर थ्रेड के अनुरूप वर्तमान Thread ऑब्जेक्ट लौटें। यदि threading मॉड्यूल के माध्यम से कॉलर का नियंत्रण नहीं बनाया गया था, तो सीमित कार्यक्षमता के साथ एक डमी थ्रेड ऑब्जेक्ट वापस आ जाता है।

threading.get_ident()

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

संस्करण 3.3 में नया।

threading.enumerate()

वर्तमान में जीवित सभी Thread ऑब्जेक्ट्स की सूची लौटाएं। सूची में डेमोनिक थ्रेड्स, डमी थ्रेड ऑब्जेक्ट्स current_thread() और मुख्य थ्रेड द्वारा बनाए गए हैं। यह समाप्त किए गए धागे और धागे को बाहर करता है जो अभी तक शुरू नहीं हुए हैं।

threading.main_thread()

मुख्य Thread ऑब्जेक्ट वापस करें। सामान्य परिस्थितियों में, मुख्य धागा वह धागा है जिससे पायथन दुभाषिया शुरू किया गया था।

संस्करण 3.4 में नया।

threading.settrace(func)

threading मॉड्यूल से शुरू होने वाले सभी थ्रेड्स के लिए एक ट्रेस फ़ंक्शन सेट करें। प्रत्येक थ्रेड के लिए sys.settrace() को sys.settrace() पारित किया जाएगा, इसके run() विधि को कहा जाता है।

threading.setprofile(func)

threading मॉड्यूल से शुरू होने वाले सभी थ्रेड्स के लिए एक प्रोफ़ाइल फ़ंक्शन सेट करें। प्रत्येक थ्रेड के लिए sys.setprofile() को sys.setprofile() पारित किया जाएगा, इसके run() विधि को कहा जाता है।

threading.stack_size([size])

नए थ्रेड बनाते समय उपयोग किए गए थ्रेड स्टैक आकार वापस करें। वैकल्पिक आकार का तर्क बाद में बनाए गए थ्रेड्स के लिए उपयोग किए जाने वाले स्टैक आकार को निर्दिष्ट करता है, और 0 होना चाहिए (प्लेटफ़ॉर्म या कॉन्फ़िगर किया गया डिफ़ॉल्ट) या कम से कम 32,768 (32 KiB) का सकारात्मक पूर्णांक मान। यदि आकार निर्दिष्ट नहीं है, तो 0 का उपयोग किया जाता है। यदि थ्रेड स्टैक का आकार बदलना असमर्थित है, तो RuntimeError उठाया जाता है। यदि निर्दिष्ट स्टैक आकार अमान्य है, तो एक ValueError उठाया जाता है और स्टैक आकार अनमॉडिफाइड है। 32 KiB वर्तमान में इंटरप्रेटर के लिए पर्याप्त स्टैक स्पेस की गारंटी के लिए न्यूनतम समर्थित स्टैक आकार मान है। ध्यान दें कि कुछ प्लेटफार्मों में स्टैक आकार के लिए मानों पर विशेष प्रतिबंध हो सकता है, जैसे कि न्यूनतम स्टैक आकार की आवश्यकता> 32 KiB या सिस्टम मेमोरी पेज आकार के गुणकों में आवंटन की आवश्यकता होती है - अधिक जानकारी के लिए प्लेटफ़ॉर्म प्रलेखन को संदर्भित किया जाना चाहिए (4 KiB पृष्ठ) आम हैं, स्टैक के आकार के लिए 4096 के गुणकों का उपयोग करना (अधिक विशिष्ट जानकारी के अभाव में सुझाया गया दृष्टिकोण)। उपलब्धता: विंडोज, पॉसिक्स थ्रेड्स के साथ सिस्टम।

यह मॉड्यूल निम्नलिखित स्थिरांक को भी परिभाषित करता है:

threading.TIMEOUT_MAX

ब्लॉकिंग फ़ंक्शन ( Lock.acquire() , RLock.acquire() , Condition.wait() , आदि) के टाइमआउट पैरामीटर के लिए अनुमत अधिकतम मान। इस मान से अधिक समयावधि निर्दिष्ट करने से OverflowError हो जाएगा।

संस्करण 3.2 में नया।

यह मॉड्यूल कई वर्गों को परिभाषित करता है, जो नीचे दिए गए अनुभागों में विस्तृत हैं।

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

नीचे वर्णित सभी विधियों को परमाणु रूप से निष्पादित किया जाता है।

थ्रेड-लोकल डेटा

थ्रेड-लोकल डेटा वह डेटा है जिसके मान थ्रेड स्पेसिफिक होते हैं। थ्रेड-लोकल डेटा को प्रबंधित करने के लिए, बस local (या उपवर्ग) का एक उदाहरण बनाएं और उस पर स्टोर की विशेषताएँ:

mydata = threading.local()
mydata.x = 1

उदाहरण के मान अलग-अलग थ्रेड के लिए अलग-अलग होंगे।

class threading.local

एक वर्ग जो थ्रेड-लोकल डेटा का प्रतिनिधित्व करता है।

अधिक विवरण और व्यापक उदाहरणों के लिए, _threading_local मॉड्यूल के प्रलेखन स्ट्रिंग देखें।

थ्रेड ऑब्जेक्ट्स

Thread वर्ग एक गतिविधि का प्रतिनिधित्व करता है जिसे नियंत्रण के एक अलग थ्रेड में चलाया जाता है। गतिविधि को निर्दिष्ट करने के दो तरीके हैं: निर्माणकर्ता को कॉल करने योग्य वस्तु को पास करके, या उपवर्ग में run() विधि को ओवरराइड करके। कोई अन्य विधियाँ (निर्माता को छोड़कर) एक उपवर्ग में ओवरराइड नहीं होनी चाहिए। दूसरे शब्दों में, केवल इस वर्ग के __init__() और run() विधियों को ओवरराइड करें।

थ्रेड ऑब्जेक्ट बन जाने के बाद, थ्रेड की start() विधि को कॉल करके इसकी गतिविधि शुरू की जानी चाहिए। यह नियंत्रण के एक अलग थ्रेड में run() विधि को आमंत्रित करता है।

एक बार जब थ्रेड की गतिविधि शुरू हो जाती है, तो थ्रेड को 'जीवित' माना जाता है। जब इसकी run() विधि समाप्त हो जाती है तो यह जीवित हो जाता है - या तो सामान्य रूप से, या एक अनहेल्दी अपवाद उठाकर। is_alive() विधि परीक्षण करती है कि क्या धागा जीवित है।

अन्य थ्रेड्स थ्रेड की join() विधि को कॉल कर सकते हैं। यह कॉलिंग थ्रेड को तब तक ब्लॉक करता है जब तक कि थ्रेड join() विधि को शामिल नहीं किया जाता है।

एक धागे का एक नाम है। नाम को कंस्ट्रक्टर को पास किया जा सकता है, और name विशेषता के माध्यम से पढ़ा या बदला जा सकता है।

एक धागे को "डेमन थ्रेड" के रूप में चिह्नित किया जा सकता है। इस ध्वज का महत्व यह है कि पूरे पायथन कार्यक्रम से बाहर निकलता है जब केवल डेमन थ्रेड्स बचे होते हैं। प्रारंभिक मूल्य बनाने वाले धागे से विरासत में मिला है। ध्वज को daemon प्रॉपर्टी या डेमन कंस्ट्रक्टर तर्क के माध्यम से सेट किया जा सकता है।

ध्यान दें

डेमन थ्रेड्स को अचानक बंद कर दिया जाता है। उनके संसाधन (जैसे खुली फाइलें, डेटाबेस लेनदेन, आदि) ठीक से जारी नहीं किए जा सकते हैं। यदि आप चाहते हैं कि आपके धागे सुशोभित रूप से बंद हो जाएं, तो उन्हें गैर-डायमोनिक बनाएं और एक Event जैसे उपयुक्त सिग्नलिंग तंत्र का उपयोग करें।

एक "मुख्य सूत्र" वस्तु है; यह पायथन कार्यक्रम में नियंत्रण के प्रारंभिक धागे से मेल खाती है। यह एक डेमॉन धागा नहीं है।

ऐसी संभावना है कि "डमी थ्रेड ऑब्जेक्ट्स" बनाए गए हैं। ये "एलियन थ्रेड्स" से संबंधित थ्रेड ऑब्जेक्ट हैं, जो थ्रेडिंग मॉड्यूल के बाहर शुरू होने वाले नियंत्रण के धागे हैं, जैसे कि सीधे सी कोड से। डमी थ्रेड ऑब्जेक्ट्स में सीमित कार्यक्षमता है; उन्हें हमेशा जीवित और शैतानी माना जाता है, और उन्हें join() नहीं किया जा सकता join() एड। वे कभी नष्ट नहीं होते हैं, क्योंकि विदेशी धागे की समाप्ति का पता लगाना असंभव है।

class threading.Thread(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)

इस रचनाकार को हमेशा कीवर्ड तर्कों के साथ बुलाया जाना चाहिए। तर्क हैं:

समूह None होना चाहिए; ThreadGroup क्लास लागू होने पर भविष्य के विस्तार के लिए आरक्षित है।

लक्ष्य run() विधि द्वारा आह्वान की जाने योग्य कॉल करने योग्य वस्तु है। किसी के लिए चूक, जिसका अर्थ कुछ भी नहीं है।

नाम धागा नाम है। डिफ़ॉल्ट रूप से, एक अद्वितीय नाम "थ्रेड- एन " फॉर्म का निर्माण किया जाता है, जहां एन एक छोटी दशमलव संख्या है।

आर्ग्स लक्ष्य आह्वान के लिए तर्क टपल है। में चूक ()

kwargs लक्ष्य आह्वान के लिए खोजशब्द तर्क का एक शब्दकोश है। डिफॉल्ट्स टू {}

यदि कोई None , तो डेमन स्पष्ट रूप से निर्धारित करता है कि क्या धागा डेमोनिक है। यदि None (डिफ़ॉल्ट), डेमोनिक संपत्ति को वर्तमान धागे से विरासत में मिला है।

यदि उपवर्ग कंस्ट्रक्टर को ओवरराइड करता है, तो Thread.__init__() को कुछ और करने से पहले बेस क्लास कंस्ट्रक्टर ( Thread.__init__() को लागू करना सुनिश्चित करें।

संस्करण 3.3 में परिवर्तित: डेमन तर्क जोड़ा गया।

start()

धागे की गतिविधि शुरू करें।

इसे एक बार प्रति थ्रेड ऑब्जेक्ट पर कॉल किया जाना चाहिए। यह ऑब्जेक्ट के run() विधि को नियंत्रण के एक अलग थ्रेड में लागू करने की व्यवस्था करता है।

यदि एक ही थ्रेड ऑब्जेक्ट पर एक से अधिक बार कॉल किया जाता है तो यह विधि एक RuntimeError को बढ़ाएगा।

run()

धागा की गतिविधि का प्रतिनिधित्व करने वाला तरीका।

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

join(timeout=None)

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

जब टाइमआउट तर्क मौजूद है और कोई None , तो यह एक फ्लोटिंग पॉइंट नंबर होना चाहिए जो सेकंड (या उसके अंश) में ऑपरेशन के लिए एक टाइमआउट निर्दिष्ट करता है। जैसे कि join() हमेशा None लौटाता, आपको कॉल करना होगा कि join() बाद join() तय join() बाद join() यदि थ्रेड अभी जीवित है, तो join() करें join() कॉल आउट टाइम हो गया।

जब टाइमआउट तर्क मौजूद नहीं है या None , तो थ्रेड समाप्त होने तक ऑपरेशन ब्लॉक हो जाएगा।

एक धागा कई बार join() सकता है join() एड।

join() एक RuntimeError उठाता है यदि वर्तमान थ्रेड में शामिल होने का प्रयास किया जाता है जिससे गतिरोध पैदा होगा। इसमें join() से पहले एक थ्रेड join() भी एक त्रुटि है और ऐसा करने का प्रयास उसी अपवाद को बढ़ाता है।

name

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

getName()
setName()

name लिए पुराना गेट्टर / सेटर एपीआई; इसके बजाय सीधे एक संपत्ति के रूप में उपयोग करें।

ident

इस थ्रेड का 'थ्रेड आइडेंटिफ़ायर' या None अगर थ्रेड शुरू नहीं किया गया है। यह एक नॉनजरो पूर्णांक है। get_ident() फ़ंक्शन देखें। थ्रेड आइडेंटिफ़ायर को रिसाइकिल किया जा सकता है जब एक थ्रेड बाहर निकलता है और एक और थ्रेड बनता है। थ्रेड निकलने के बाद भी पहचानकर्ता उपलब्ध है।

is_alive()

लौटें कि क्या धागा जीवित है।

यह विधि run() विधि के शुरू होने से ठीक पहले run() विधि के समाप्त होने से ठीक पहले लौटती है। मॉड्यूल फ़ंक्शन enumerate() सभी जीवित थ्रेड्स की एक सूची देता है।

daemon

एक बूलियन मान दर्शाता है कि यह धागा एक डेमन थ्रेड (सही) है या नहीं (गलत)। इसे start() करने से पहले सेट किया जाना चाहिए start() कहा जाता है, अन्यथा RuntimeError को उठाया जाता है। इसका प्रारंभिक मूल्य निर्माण धागा से विरासत में मिला है; मुख्य धागा डेमॉन धागा नहीं है और इसलिए मुख्य धागे में बनाए गए सभी धागे daemon = False लिए डिफ़ॉल्ट हैं।

पूरे पायथन कार्यक्रम से बाहर निकलता है जब कोई जीवित गैर-डेमन थ्रेड्स नहीं बचे हैं।

isDaemon()
setDaemon()

daemon लिए पुराना गेट्टर / सेटर एपीआई; इसके बजाय सीधे एक संपत्ति के रूप में उपयोग करें।

CPython कार्यान्वयन विवरण: CPython में, ग्लोबल इंटरप्रेटर लॉक के कारण , केवल एक धागा पायथन कोड को एक ही बार में निष्पादित कर सकता है (भले ही कुछ प्रदर्शन उन्मुख पुस्तकालय इस सीमा को पार कर सकते हैं)। यदि आप चाहते हैं कि आपका एप्लिकेशन मल्टी-कोर मशीनों के कम्प्यूटेशनल संसाधनों का बेहतर उपयोग करे, तो आपको multiprocessing या concurrent.futures.ProcessPoolExecutor का उपयोग करने की सलाह दी जाती है। concurrent.futures.ProcessPoolExecutor । हालाँकि, थ्रेडिंग अभी भी एक उपयुक्त मॉडल है यदि आप एक साथ कई I / O- बाउंड कार्य चलाना चाहते हैं।

वस्तुओं को लॉक करें

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

एक आदिम ताला दो राज्यों में से एक में है, "बंद" या "अनलॉक"। यह अनलॉक की गई स्थिति में बनाया गया है। इसकी दो बुनियादी विधियाँ हैं, Lock.acquire() और release() । जब स्थिति अनलॉक हो जाती है, तो Lock.acquire() लॉक करने के लिए राज्य को बदल देता है और तुरंत लौटता है। जब राज्य लॉक हो जाता है, तो एक थ्रेड में कॉल release() तक Lock.acquire() ब्लॉक हो जाता है release() दूसरे थ्रेड में release() इसे अनलॉक करने के लिए बदल जाता है, तब Lock.acquire() कॉल लॉक और रिटर्न पर रीसेट करता है। release() विधि को केवल बंद अवस्था में बुलाया जाना चाहिए; यह स्थिति को अनलॉक करने के लिए बदल देता है और तुरंत लौटता है। यदि अनलॉक किए गए लॉक को जारी करने का प्रयास किया जाता है, तो एक RuntimeError उठाया जाएगा।

ताले भी संदर्भ प्रबंधन प्रोटोकॉल का समर्थन करते हैं।

जब एक से अधिक थ्रेड को Lock.acquire() में अवरुद्ध किया जाता है Lock.acquire() राज्य के अनलॉक होने की प्रतीक्षा करता है, तो केवल एक थ्रेड आगे बढ़ने पर release() कॉल release() राज्य को अनलॉक करने के लिए रीसेट करता है; वेटिंग थ्रेड्स में से एक को परिभाषित नहीं किया गया है, और पूरे कार्यान्वयन में भिन्न हो सकता है।

सभी तरीकों को परमाणु रूप से निष्पादित किया जाता है।

class threading.Lock

आदिम ताला वस्तुओं को लागू करने वाला वर्ग। एक बार जब एक थ्रेड ने लॉक प्राप्त कर लिया है, तो बाद में इसे ब्लॉक करने का प्रयास करता है, जब तक कि इसे जारी नहीं किया जाता है; कोई भी धागा इसे जारी कर सकता है।

ध्यान दें कि Lock वास्तव में एक फ़ैक्ट्री फ़ंक्शन है जो प्लेटफ़ॉर्म द्वारा समर्थित कंक्रीट लॉक क्लास के सबसे कुशल संस्करण का एक उदाहरण देता है।

acquire(blocking=True, timeout=-1)

एक ताला, अवरुद्ध या गैर-अवरुद्ध प्राप्त करें।

जब True (डिफ़ॉल्ट) पर सेट किए गए अवरुद्ध तर्क के साथ आह्वान किया जाए, तब तक ब्लॉक करें जब तक कि लॉक अनलॉक न हो जाए, फिर इसे लॉक पर सेट करें और True वापस लौटें।

जब ब्लॉक किए गए तर्क को False सेट किया जाता है, तो ब्लॉक न करें। यदि True अवरुद्ध करने वाले सेट के साथ कॉल अवरुद्ध होता है, तो तुरंत False लौटें; अन्यथा, लॉक को लॉक पर सेट करें और True लौटें।

जब फ्लोटिंग-पॉइंट टाइमआउट तर्क को एक सकारात्मक मान पर सेट किया जाता है, तो टाइमआउट द्वारा निर्दिष्ट सेकंड के अधिकांश संख्या में ब्लॉक करें और जब तक लॉक का अधिग्रहण नहीं किया जा सकता है। -1 का टाइमआउट तर्क अनबाउंड प्रतीक्षा को निर्दिष्ट करता है। ब्लॉकिंग गलत होने पर टाइमआउट निर्दिष्ट करना निषिद्ध है।

रिटर्न वैल्यू True यदि लॉक सफलतापूर्वक प्राप्त किया गया है, तो False यदि नहीं (उदाहरण के लिए यदि समय समाप्त हो गया है)।

3.2 संस्करण में बदला: टाइमआउट पैरामीटर नया है।

3.2 संस्करण में बदला: अंतर्निहित थ्रेडिंग कार्यान्वयन इसका समर्थन करता है तो लॉक अधिग्रहण अब POSIX पर संकेतों द्वारा बाधित किया जा सकता है।

release()

एक ताला जारी करो। यह किसी भी धागे से बुलाया जा सकता है, न केवल उस धागे से जिसने ताला का अधिग्रहण किया है।

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

अनलॉक किए गए लॉक पर जब आह्वान किया जाता है, तो RuntimeError को उठाया जाता है।

कोई रिटर्न वैल्यू नहीं है।

RLock ऑब्जेक्ट्स

एक रेन्डेंट लॉक एक सिंक्रनाइज़ेशन आदिम है जिसे एक ही थ्रेड द्वारा कई बार प्राप्त किया जा सकता है। आंतरिक रूप से, यह आदिम तालों द्वारा उपयोग किए गए लॉक / अनलॉक किए गए राज्य के अलावा "स्वयं के धागे" और "पुनरावृत्ति स्तर" की अवधारणाओं का उपयोग करता है। बंद अवस्था में, कुछ धागे ताला का मालिक है; अनलॉक की गई स्थिति में, कोई भी धागा इसका मालिक नहीं है।

लॉक को लॉक करने के लिए, एक थ्रेड इसके RLock.acquire() विधि को कॉल करता है; जब धागा लॉक का मालिक हो जाता है तो यह रिटर्न देता है। लॉक को अनलॉक करने के लिए, एक थ्रेड इसकी release() विधि को कॉल करता है। Lock.acquire() / release() कॉल जोड़े को नेस्टेड किया जा सकता है; केवल अंतिम release() (सबसे बाहरी जोड़ी का release() लॉक को अनलॉक करने के लिए रीसेट करता है और आगे बढ़ने के लिए Lock.acquire() में अवरुद्ध एक और धागा की अनुमति देता है।

रेंटेंट लॉक भी संदर्भ प्रबंधन प्रोटोकॉल का समर्थन करते हैं।

class threading.RLock

यह वर्ग पुनरावृत्ति ताला वस्तुओं को लागू करता है। एक रेंटेंट लॉक को उस थ्रेड द्वारा जारी किया जाना चाहिए जिसने इसे अधिग्रहित किया था। एक बार जब एक धागा ने एक रेन्ट्रेंट लॉक हासिल कर लिया है, तो वही धागा बिना ब्लॉक किए फिर से हासिल कर सकता है; धागे को इसे अधिग्रहित करने के बाद हर बार एक बार जारी करना होगा।

ध्यान दें कि RLock वास्तव में एक फैक्ट्री फ़ंक्शन है जो प्लेटफ़ॉर्म द्वारा समर्थित कंक्रीट RLock वर्ग के सबसे कुशल संस्करण का एक उदाहरण देता है।

acquire(blocking=True, timeout=-1)

एक ताला, अवरुद्ध या गैर-अवरुद्ध प्राप्त करें।

जब तर्कों के बिना आह्वान किया जाता है: यदि यह धागा पहले से ही ताला का मालिक है, तो पुनरावृत्ति स्तर को एक से बढ़ाएं, और तुरंत वापस लौटें। अन्यथा, यदि एक और धागा लॉक का मालिक है, तो लॉक अनलॉक होने तक ब्लॉक करें। एक बार लॉक अनलॉक होने के बाद (किसी भी धागे के स्वामित्व में नहीं), फिर स्वामित्व को पकड़ो, एक को पुनरावृत्ति स्तर सेट करें, और वापस लौटें। यदि एक से अधिक थ्रेड को लॉक अनलॉक होने तक प्रतीक्षा में अवरुद्ध किया जाता है, तो एक समय में केवल लॉक का स्वामित्व हड़पने में सक्षम होगा। इस मामले में कोई रिटर्न वैल्यू नहीं है।

जब सही पर सेट किए गए अवरुद्ध तर्क के साथ आह्वान किया जाता है, तो जब तर्क के बिना बुलाया जाता है, तो वही करें और सच लौटें।

जब ब्लॉकिंग तर्क के साथ गलत को सेट किया जाता है, तो ब्लॉक न करें। यदि एक तर्क के बिना एक कॉल अवरुद्ध होता है, तो तुरंत झूठी लौटें; अन्यथा, जब तर्क के बिना कहा जाता है, तो वही करें और सही लौटें।

जब फ्लोटिंग-पॉइंट टाइमआउट तर्क को एक सकारात्मक मान पर सेट किया जाता है, तो टाइमआउट द्वारा निर्दिष्ट सेकंड के अधिकांश संख्या में ब्लॉक करें और जब तक लॉक का अधिग्रहण नहीं किया जा सकता है। यदि लॉकआउट समय समाप्त हो गया है, तो गलत, यदि लॉक हासिल कर लिया गया है तो सही लौटें।

3.2 संस्करण में बदला: टाइमआउट पैरामीटर नया है।

release()

एक ताला जारी करें, पुनरावृत्ति स्तर को घटाएं। अगर गिरावट के बाद यह शून्य है, तो लॉक को अनलॉक किए गए (किसी भी थ्रेड के स्वामित्व में नहीं) पर रीसेट करें, और यदि किसी अन्य थ्रेड को लॉक के अनलॉक होने के इंतजार में अवरुद्ध किया जाता है, तो उनमें से एक को आगे बढ़ने की अनुमति दें। यदि वेतनवृद्धि के बाद पुनरावृत्ति स्तर अभी भी गैर-शून्य है, तो लॉक लॉक रहता है और कॉलिंग थ्रेड के स्वामित्व में है।

केवल इस विधि को कॉल करें जब कॉलिंग थ्रेड लॉक का मालिक हो। यदि लॉक अनलॉक किया जाता है, तो इस पद्धति को कॉल किया जाता है, तो एक RuntimeError को उठाया जाता है।

कोई रिटर्न वैल्यू नहीं है।

दशा वस्तु

एक कंडीशन वैरिएबल हमेशा किसी तरह के लॉक से जुड़ा होता है; इसे पास किया जा सकता है या डिफ़ॉल्ट रूप से बनाया जाएगा। जब एक ही लॉक को कई कंडीशन वैरिएबल्स को शेयर करना होगा, तो उसमें से एक पास करना उपयोगी है। लॉक स्थिति ऑब्जेक्ट का हिस्सा है: आपको इसे अलग से ट्रैक करने की आवश्यकता नहीं है।

एक शर्त चर संदर्भ प्रबंधन प्रोटोकॉल का पालन करता है : कथन के with प्रयोग संलग्न ब्लॉक की अवधि के लिए संबंधित लॉक को प्राप्त करता है। acquire() और release() विधियां भी संबंधित लॉक के संबंधित तरीकों को कॉल करती हैं।

अन्य तरीकों को संबंधित लॉक के साथ बुलाया जाना चाहिए। Condition.wait() विधि लॉक को रिलीज़ करती है, और तब तक ब्लॉक करती है जब तक कि एक और थ्रेड notify() या notify_all() को कॉल करके जागता नहीं है। एक बार जागृत होने पर, Condition.wait() लॉक को पुनः प्राप्त करता है और वापस लौटता है। टाइमआउट निर्दिष्ट करना भी संभव है।

notify() विधि किसी भी प्रतीक्षा कर रहे हैं, तो स्थिति चर के लिए इंतजार कर रहे थ्रेड्स में से एक को जागता है। notify_all() विधि स्थिति चर के लिए प्रतीक्षा कर रहे सभी थ्रेड्स को notify_all()

नोट: notify() और notify_all() विधियाँ ताला जारी नहीं करती हैं; इसका अर्थ है कि जागृत किया गया धागा या धागा उनके Condition.wait() से वापस नहीं आएगा Condition.wait() तुरंत कॉल करें, लेकिन केवल तभी जब थ्रेड को notify() या notify() notify_all() अंत में लॉक के स्वामित्व को छोड़ दें।

हालत चर का उपयोग करते हुए विशिष्ट प्रोग्रामिंग शैली कुछ साझा स्थिति तक पहुंच को सिंक्रनाइज़ करने के लिए लॉक का उपयोग करती है; राज्य कॉल कॉल के किसी विशेष परिवर्तन में रुचि रखने वाले थ्रेड्स बार-बार वांछित स्थिति को देखने तक Condition.wait() , जबकि थ्रेड्स जो स्टेट कॉल notify_all() या notify_all() संशोधित करते हैं, जब वे राज्य को इस तरह से बदलते हैं कि यह संभवतः हो सकता है वेटर्स में से एक के लिए एक वांछित राज्य। उदाहरण के लिए, निम्नलिखित कोड असीमित बफर क्षमता के साथ एक सामान्य उत्पादक-उपभोक्ता स्थिति है:

# Consume one item
with cv:
    while not an_item_is_available():
        cv.wait()
    get_an_available_item()

# Produce one item
with cv:
    make_an_item_available()
    cv.notify()

आवेदन की स्थिति के लिए लूप चेकिंग आवश्यक है क्योंकि Condition.wait() एक मनमाने ढंग से लंबे समय के बाद वापस आ सकती है, और जो स्थिति notify() कॉल को प्रेरित करती है वह अब सही नहीं हो सकती है। यह बहु-थ्रेडेड प्रोग्रामिंग के लिए अंतर्निहित है। wait_for() विधि का उपयोग हालत की जाँच को स्वचालित करने के लिए किया जा सकता है, और टाइमआउट की गणना को आसान बनाता है:

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

notify() और notify_all() बीच चयन करने के लिए, विचार करें कि क्या एक राज्य परिवर्तन केवल एक या कई प्रतीक्षा थ्रेड्स के लिए दिलचस्प हो सकता है। एक विशिष्ट निर्माता-उपभोक्ता स्थिति में, बफर में एक आइटम को जोड़ने के लिए केवल एक उपभोक्ता धागा को जगाने की आवश्यकता होती है।

class threading.Condition(lock=None)

यह वर्ग स्थिति चर वस्तुओं को लागू करता है। एक स्थिति चर एक या एक से अधिक थ्रेड को प्रतीक्षा करने की अनुमति देता है जब तक कि वे किसी अन्य थ्रेड द्वारा अधिसूचित न हों।

यदि लॉक तर्क दिया जाता है और कोई None , तो यह Lock या RLock ऑब्जेक्ट होना चाहिए, और इसका उपयोग अंतर्निहित लॉक के रूप में किया जाता है। अन्यथा, एक नया RLock ऑब्जेक्ट अंतर्निहित लॉक के रूप में बनाया और उपयोग किया जाता है।

संस्करण 3.3 में परिवर्तित: फ़ैक्टरी फ़ंक्शन से एक वर्ग में बदल गया।

acquire(*args)

अंतर्निहित लॉक को प्राप्त करें। यह विधि अंतर्निहित लॉक पर संबंधित विधि को कॉल करती है; रिटर्न वैल्यू वह है जो वह विधि रिटर्न करती है।

release()

अंतर्निहित लॉक जारी करें। यह विधि अंतर्निहित लॉक पर संबंधित विधि को कॉल करती है; कोई वापसी मूल्य नहीं है।

wait(timeout=None)

अधिसूचित होने तक या समय समाप्त होने तक प्रतीक्षा करें। यदि कॉलिंग थ्रेड ने इस पद्धति को कॉल करने पर लॉक को अधिग्रहित नहीं किया है, तो एक RuntimeError उठाया जाता है।

यह विधि अंतर्निहित लॉक को रिलीज़ करती है, और तब तक ब्लॉक करती है जब तक कि यह एक notify_all() या notify_all() द्वारा किसी अन्य थ्रेड में एक ही स्थिति चर के लिए या वैकल्पिक टाइमआउट होने तक जागृत न हो। एक बार जागृत हो जाने या समय समाप्त होने पर, यह लॉक को पुनः प्राप्त करता है और वापस लौटता है।

जब टाइमआउट तर्क मौजूद है और कोई None , तो यह एक फ्लोटिंग पॉइंट नंबर होना चाहिए जो सेकंड (या उसके अंश) में ऑपरेशन के लिए एक टाइमआउट निर्दिष्ट करता है।

जब अंतर्निहित लॉक एक RLock , तो इसकी release() विधि का उपयोग करके इसे जारी नहीं किया जाता है, क्योंकि यह वास्तव में लॉक को अनलॉक नहीं कर सकता है जब इसे कई बार पुनरावर्ती रूप से प्राप्त किया गया था। इसके बजाय, RLock वर्ग का एक आंतरिक इंटरफ़ेस उपयोग किया जाता है, जो वास्तव में इसे तब भी अनलॉक करता है जब इसे कई बार पुनरावर्ती रूप से प्राप्त किया गया हो। एक अन्य आंतरिक इंटरफ़ेस का उपयोग तब पुनर्संरचना स्तर को पुनर्स्थापित करने के लिए किया जाता है जब लॉक को पुनः प्राप्त किया जाता है।

रिटर्न वैल्यू तब तक True जब तक किसी दिए गए टाइमआउट की समय सीमा समाप्त नहीं होती।

3.2 संस्करण में बदला: पहले, विधि हमेशा None लौटा।

wait_for(predicate, timeout=None)

तब तक प्रतीक्षा करें जब तक कि कोई शर्त सत्य का मूल्यांकन न करे विधेय एक कॉल करने योग्य होना चाहिए जिसके परिणामस्वरूप एक बूलियन मूल्य के रूप में व्याख्या की जाएगी। प्रतीक्षा करने के लिए अधिकतम समय देने के लिए एक टाइमआउट प्रदान किया जा सकता है।

जब तक विधेय संतुष्ट नहीं हो जाता है, या जब तक कोई टाइमआउट नहीं होता है तब तक यह उपयोगिता विधि Condition.wait() बार-बार कह सकती है। वापसी मान विधेय का अंतिम रिटर्न मूल्य है और विधि का समय समाप्त होने पर False मूल्यांकन करेगा।

टाइमआउट सुविधा को अनदेखा करना, इस पद्धति को कॉल करना लगभग लिखने के बराबर है:

while not predicate():
    cv.wait()

इसलिए, वही नियम Condition.wait() साथ लागू होते हैं Condition.wait() : जब कॉल किया जाता है तो लॉक को आयोजित किया जाना चाहिए और रिटर्न पर फिर से अधिग्रहित किया जाना चाहिए। विधेय का मूल्यांकन लॉक के साथ किया जाता है।

संस्करण 3.2 में नया।

notify(n=1)

डिफ़ॉल्ट रूप से, इस स्थिति पर प्रतीक्षा कर रहा है एक धागा, यदि कोई हो तो। यदि कॉलिंग थ्रेड ने इस पद्धति को कॉल करने पर लॉक को अधिग्रहित नहीं किया है, तो एक RuntimeError उठाया जाता है।

यह विधि स्थिति चर के लिए इंतजार कर रहे थ्रेड्स के अधिकांश एन पर उठती है; यदि कोई थ्रेड इंतजार कर रहा है तो यह नो-ऑप है।

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

नोट: एक जागृत धागा वास्तव में अपने Condition.wait() कॉल से वापस नहीं आता है जब तक कि यह लॉक को फिर से जमा नहीं कर सकता है। चूंकि notify() लॉक जारी नहीं करता है, इसके कॉलर को चाहिए।

notify_all()

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

सेमफोर ऑब्जेक्ट

यह कंप्यूटर विज्ञान के इतिहास में सबसे पुराने सिंक्रोनाइज़ेशन प्राइमेटिव्स में से एक है, जिसका आविष्कार शुरुआती डच कंप्यूटर साइंटिस्ट Edsger W. Dijkstra ने किया था (उन्होंने acquire() और acquire() और release() ) के बजाय P() और V() नामों का इस्तेमाल किया था।

एक सेमाफोर एक आंतरिक काउंटर का प्रबंधन करता है जो प्रत्येक acquire() कॉल और प्रत्येक release() कॉल द्वारा संवर्धित होता है। काउंटर कभी भी शून्य से नीचे नहीं जा सकता है; जब acquire() पाता है कि यह शून्य है, यह ब्लॉक करता है, तब तक प्रतीक्षा करता है जब तक कि कुछ अन्य थ्रेड कॉल release()

सेमाफोर्स संदर्भ प्रबंधन प्रोटोकॉल का भी समर्थन करते हैं।

class threading.Semaphore(value=1)

यह वर्ग अर्धवृत्त वस्तुओं को लागू करता है। एक सेमाफोर एक परमाणु काउंटर को release() करने की संख्या का प्रतिनिधित्व करता है release() कॉलस को acquire() की संख्या acquire() कॉल, साथ ही एक प्रारंभिक मूल्य। यदि आवश्यक हो तो acquire() विधि तब तक अवरुद्ध हो जाती है जब तक कि यह काउंटर को नकारात्मक बनाये बिना वापस लौट सके। यदि नहीं दिया गया है, तो मान 1 से चूक जाता है।

वैकल्पिक तर्क आंतरिक काउंटर के लिए प्रारंभिक मूल्य देता है; यह 1 को चूकता है। यदि दिया गया मान 0 से कम है, तो ValueError को उठाया जाता है।

संस्करण 3.3 में परिवर्तित: फ़ैक्टरी फ़ंक्शन से एक वर्ग में बदल गया।

acquire(blocking=True, timeout=None)

एक अर्धकुंभ प्राप्त करें।

जब बहस के बिना आह्वान किया जाता है:

  • यदि आंतरिक काउंटर प्रवेश पर शून्य से बड़ा है, तो इसे एक से घटाएं और तुरंत सही लौटें।
  • यदि आंतरिक काउंटर प्रविष्टि पर शून्य है, तब तक ब्लॉक करें जब तक कि कॉल release() । एक बार जागने (और काउंटर 0 से अधिक है), काउंटर को 1 से घटाएं और सही लौटें। वास्तव में प्रत्येक थ्रेड को कॉल करने के लिए release() । जिस क्रम में धागे जागते हैं, उस पर भरोसा नहीं किया जाना चाहिए।

जब झूठी के साथ अवरुद्ध सेट के साथ आह्वान किया जाता है, तो ब्लॉक न करें। यदि एक तर्क के बिना एक कॉल अवरुद्ध होता है, तो तुरंत झूठी लौटें; अन्यथा, जब तर्क के बिना कहा जाता है, तो वही करें और सही लौटें।

जब None अलावा एक टाइमआउट के साथ आह्वान किया जाता है, तो यह अधिकांश टाइमआउट सेकंड में ब्लॉक हो जाएगा। यदि अधिग्रहण उस अंतराल में सफलतापूर्वक पूरा नहीं होता है, तो गलत लौटें। अन्यथा वापस लौटें।

3.2 संस्करण में बदला: टाइमआउट पैरामीटर नया है।

release()

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

class threading.BoundedSemaphore(value=1)

श्रेणीबद्ध बंधी हुई सीमाफोर वस्तुओं को लागू करना। एक बंधे हुए सेमाफोर की जाँच यह सुनिश्चित करने के लिए करती है कि इसका वर्तमान मूल्य इसके प्रारंभिक मूल्य से अधिक न हो। यदि यह करता है, तो ValueError को उठाया जाता है। ज्यादातर स्थितियों में सीमित क्षमता वाले संसाधनों की रक्षा के लिए सेमाफोर का उपयोग किया जाता है। यदि अर्धकुंभ बहुत बार जारी किया जाता है तो यह बग का संकेत है। यदि नहीं दिया गया है, तो मान 1 से चूक जाता है।

संस्करण 3.3 में परिवर्तित: फ़ैक्टरी फ़ंक्शन से एक वर्ग में बदल गया।

Semaphore उदाहरण

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

maxconnections = 5
# ...
pool_sema = BoundedSemaphore(value=maxconnections)

जब एक बार काम किया जाता है, तो वर्कर थ्रेड्स सेमाफोर के अधिग्रहण और रिलीज के तरीकों को कहते हैं, जब उन्हें सर्वर से कनेक्ट करने की आवश्यकता होती है:

with pool_sema:
    conn = connectdb()
    try:
        # ... use connection ...
    finally:
        conn.close()

एक बंधे हुए सेमाफोर के उपयोग से यह संभावना कम हो जाती है कि एक प्रोग्रामिंग त्रुटि जिसके कारण सेमाफोर को अधिग्रहित करने से अधिक जारी किया जाएगा।

इवेंट ऑब्जेक्ट

यह थ्रेड्स के बीच संचार के लिए सबसे सरल तंत्रों में से एक है: एक थ्रेड किसी घटना को इंगित करता है और अन्य थ्रेड इसके लिए प्रतीक्षा करते हैं।

एक ईवेंट ऑब्जेक्ट एक आंतरिक ध्वज का प्रबंधन करता है जिसे set() विधि के साथ सही करने के लिए सेट किया जा सकता है और clear() विधि के साथ गलत पर रीसेट किया जा सकता है। wait() विधि तब तक अवरुद्ध होती है जब तक झंडा सत्य नहीं होता।

class threading.Event

घटना वस्तुओं को लागू करने वाला वर्ग। एक घटना एक झंडे का प्रबंधन करती है जिसे set() विधि के साथ सच किया जा सकता है और clear() विधि के साथ गलत पर रीसेट किया जा सकता है। wait() विधि तब तक अवरुद्ध होती है जब तक झंडा सत्य नहीं होता। ध्वज शुरू में झूठा है।

संस्करण 3.3 में परिवर्तित: फ़ैक्टरी फ़ंक्शन से एक वर्ग में बदल गया।

is_set()

यदि आंतरिक ध्वज सत्य है और केवल तभी सत्य लौटें।

set()

आंतरिक ध्वज को सही पर सेट करें। इसके सत्य होने की प्रतीक्षा करने वाले सभी सूत्र जागृत होते हैं। एक बार झंडा सही होने पर wait() कॉल करने वाले धागे बिल्कुल भी ब्लॉक नहीं होंगे।

clear()

झंडे को आंतरिक ध्वज रीसेट करें। इसके बाद, थ्रेड्स कॉलिंग wait() set() होने तक ब्लॉक रहेगा set() आंतरिक ध्वज को फिर से सच करने के लिए सेट करने के लिए कहा जाता है।

wait(timeout=None)

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

जब टाइमआउट तर्क मौजूद है और कोई None , तो यह एक फ्लोटिंग पॉइंट नंबर होना चाहिए जो सेकंड (या उसके अंश) में ऑपरेशन के लिए एक टाइमआउट निर्दिष्ट करता है।

यह विधि तब तक सही रहती है जब और अगर आंतरिक ध्वज को सही पर सेट किया गया हो, या तो प्रतीक्षा कॉल से पहले या प्रतीक्षा शुरू होने के बाद, इसलिए यह हमेशा True लौटेगा सिवाय अगर कोई टाइमआउट दिया गया हो और ऑपरेशन का समय समाप्त हो गया हो।

संस्करण 3.1 में बदला गया: पहले, विधि हमेशा None

टाइमर ऑब्जेक्ट्स

यह वर्ग एक ऐसी कार्रवाई का प्रतिनिधित्व करता है जिसे एक निश्चित समय बीतने के बाद ही चलाया जाना चाहिए - एक टाइमर। Timer Thread का एक उपवर्ग है और जैसे कि कस्टम थ्रेड बनाने के उदाहरण के रूप में भी कार्य करता है।

टाइमर प्रारंभ के रूप में, थ्रेड्स के साथ शुरू किए जाते हैं। cancel() विधि को कॉल करके टाइमर को रोका जा सकता है (इसकी कार्रवाई शुरू होने से पहले cancel() । अंतराल टाइमर कार्रवाई से पहले इंतजार करेगा अपनी कार्रवाई उपयोगकर्ता द्वारा निर्दिष्ट अंतराल के समान नहीं हो सकता है।

उदाहरण के लिए:

def hello():
    print("hello, world")

t = Timer(30.0, hello)
t.start()  # after 30 seconds, "hello, world" will be printed
class threading.Timer(interval, function, args=None, kwargs=None)

एक टाइमर बनाएं जो तर्कों के साथ फ़ंक्शन चलाएगा और कीवर्ड तर्क kwargs , अंतराल सेकंड बीतने के बाद। यदि आर्ग्स None (डिफ़ॉल्ट) तो एक खाली सूची का उपयोग किया जाएगा। यदि kwargs None (डिफ़ॉल्ट) तो एक खाली तानाशाही का उपयोग किया जाएगा।

संस्करण 3.3 में परिवर्तित: फ़ैक्टरी फ़ंक्शन से एक वर्ग में बदल गया।

cancel()

टाइमर बंद करो, और टाइमर की कार्रवाई के निष्पादन को रद्द करें। यह तभी काम करेगा जब टाइमर अभी भी अपने वेटिंग स्टेज में है।

बैरियर ऑब्जेक्ट्स

संस्करण 3.2 में नया।

यह वर्ग एक निश्चित संख्या में धागे द्वारा उपयोग के लिए एक सरल तुल्यकालन आदिम प्रदान करता है, जिन्हें एक-दूसरे की प्रतीक्षा करने की आवश्यकता होती है। प्रत्येक थ्रेड्स wait() विधि को कॉल करके बाधा को पारित करने की कोशिश करता है और तब तक ब्लॉक करेगा जब तक कि सभी थ्रेड्स ने अपना wait() कॉल नहीं किया है। इस बिंदु पर, थ्रेड्स एक साथ जारी किए जाते हैं।

एक ही संख्या के थ्रेड्स के लिए अवरोध को किसी भी समय पुन: उपयोग किया जा सकता है।

एक उदाहरण के रूप में, यहां एक क्लाइंट और सर्वर थ्रेड को सिंक्रनाइज़ करने का एक सरल तरीका है:

b = Barrier(2, timeout=5)

def server():
    start_server()
    b.wait()
    while True:
        connection = accept_connection()
        process_server_connection(connection)

def client():
    b.wait()
    while True:
        connection = make_connection()
        process_client_connection(connection)
class threading.Barrier(parties, action=None, timeout=None)

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

wait(timeout=None)

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

रिटर्न मान 0 से पार्टियों तक की सीमा में एक पूर्णांक है - 1, प्रत्येक थ्रेड के लिए अलग। यह कुछ विशेष हाउसकीपिंग करने के लिए एक धागे का चयन करने के लिए इस्तेमाल किया जा सकता है, जैसे:

i = barrier.wait()
if i == 0:
    # Only one thread needs to print this
    print("passed the barrier")

यदि निर्माणकर्ता को एक कार्रवाई प्रदान की गई थी, तो थ्रेड्स में से एक ने इसे जारी होने से पहले बुलाया होगा। क्या इस कॉल में कोई त्रुटि है, बाधा को टूटी हुई स्थिति में डाल दिया जाना चाहिए।

यदि कॉल आउट होता है, तो बाधा को टूटी हुई स्थिति में डाल दिया जाता है।

यह विधि एक BrokenBarrierError अपवाद को बढ़ा सकती है यदि बाधा टूटी हुई है या रीसेट हो रही है जबकि एक थ्रेड प्रतीक्षा कर रहा है।

reset()

अवरोध को डिफ़ॉल्ट, खाली स्थिति पर लौटाएं। इस पर प्रतीक्षा कर रहे किसी भी धागे को BrokenBarrierError अपवाद प्राप्त होगा।

ध्यान दें कि इस फ़ंक्शन का उपयोग करने पर कुछ बाहरी सिंक्रनाइज़ेशन की आवश्यकता हो सकती है यदि अन्य थ्रेड्स हैं जिनकी स्थिति अज्ञात है। यदि एक अवरोध टूट गया है तो इसे छोड़ना और एक नया बनाना बेहतर हो सकता है।

abort()

अवरोध को टूटी अवस्था में रखें। यह BrokenBarrierError साथ wait() करने के लिए किसी भी सक्रिय या भविष्य कॉल का कारण बनता है। उदाहरण के लिए इसका उपयोग करें यदि आवेदन में गतिरोध से बचने के लिए गर्भपात करने की आवश्यकता है।

यह केवल एक समझदार टाइमआउट मान के साथ बाधा पैदा करने के लिए बेहतर हो सकता है, जो कि थ्रेड्स में से एक के खिलाफ पहरा देने के लिए स्वचालित रूप से गार्ड हो।

parties

बाधा को पारित करने के लिए आवश्यक थ्रेड्स की संख्या।

n_waiting

वर्तमान में बाधा में प्रतीक्षा कर रहे थ्रेड्स की संख्या।

broken

एक बूलियन जो True यदि अवरोधक टूटी अवस्था में है।

exception threading.BrokenBarrierError

RuntimeError जब Barrier ऑब्जेक्ट रीसेट या टूट जाता है, तो यह अपवाद, का एक उपवर्ग , उठाया जाता है।

बयान के साथ ताले, शर्तों और सेमाफोर का उपयोग करना

इस मॉड्यूल द्वारा प्रदान की जाने वाली सभी वस्तुएं acquire() और release() विधियां एक with बयान के लिए संदर्भ प्रबंधकों के रूप में उपयोग की जा सकती हैं । acquire() जब ब्लॉक दर्ज किया गया है विधि बुलाया जाएगा, और release() जब ब्लॉक से बाहर निकल गया है बुलाया जाएगा। इसलिए, निम्नलिखित स्निपेट:

with some_lock:
    # do something...

के बराबर है:

some_lock.acquire()
try:
    # do something...
finally:
    some_lock.release()

वर्तमान में, Lock , RLock , Condition , Semaphore , और BoundedSemaphore वस्तुओं के रूप में इस्तेमाल किया जा सकता with बयान संदर्भ प्रबंधकों।

Original text