Python 3.7 - Synchronization Primitives

सिंक्रोनाइज़ेशन प्रिमिटिव




python

सिंक्रोनाइज़ेशन प्रिमिटिव

asyncio तुल्यकालन आदिम दो महत्वपूर्ण गुहाओं के साथ threading मॉड्यूल के समान होने के लिए डिज़ाइन किए गए हैं:

  • asyncio प्राइमेटिव्स थ्रेड-सुरक्षित नहीं हैं, इसलिए उन्हें ओएस थ्रेड सिंक्रोनाइज़ेशन (उस के लिए threading उपयोग करें) के लिए उपयोग नहीं किया जाना चाहिए;
  • इन सिंक्रनाइज़ेशन प्राइमेटीज़ के तरीके टाइमआउट तर्क को स्वीकार नहीं करते हैं; टाइमआउट के साथ संचालन करने के लिए asyncio.wait_for() फ़ंक्शन का उपयोग करें।

asyncio में निम्नलिखित मूल sychronization primitives है:

ताला

class asyncio.Lock(*, loop=None)

Asyncio कार्यों के लिए एक म्यूटेक्स लॉक लागू करता है। धागा-सुरक्षित नहीं।

एक साझा संसाधन के लिए विशेष पहुंच की गारंटी के लिए एक एसिंसीओ लॉक का उपयोग किया जा सकता है।

लॉक का उपयोग करने का पसंदीदा तरीका कथन के async with एक async with :

lock = asyncio.Lock()

# ... later
async with lock:
    # access shared state

जो इसके बराबर है:

lock = asyncio.Lock()

# ... later
await lock.acquire()
try:
    # access shared state
finally:
    lock.release()
coroutine acquire()

ताला को हासिल करो।

यह विधि लॉक अनलॉक होने तक प्रतीक्षा करती है , इसे लॉक करने के लिए सेट करती है और True लौटाती है।

release()

ताला जारी करो।

जब ताला बंद हो जाता है , तो इसे अनलॉक करने के लिए रीसेट करें और वापस लौटें।

यदि ताला खुला है , तो एक RuntimeError को उठाया जाता है।

locked()

अगर लॉक है तो True लौटें।

घटना

class asyncio.Event(*, loop=None)

एक घटना वस्तु। धागा-सुरक्षित नहीं।

एक asyncio घटना कई asyncio कार्यों को सूचित करने के लिए इस्तेमाल किया जा सकता है कि कुछ घटना हुई है।

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

उदाहरण:

async def waiter(event):
    print('waiting for it ...')
    await event.wait()
    print('... got it!')

async def main():
    # Create an Event object.
    event = asyncio.Event()

    # Spawn a Task to wait until 'event' is set.
    waiter_task = asyncio.create_task(waiter(event))

    # Sleep for 1 second and set the event.
    await asyncio.sleep(1)
    event.set()

    # Wait until the waiter task is finished.
    await waiter_task

asyncio.run(main())
coroutine wait()

घटना सेट होने तक प्रतीक्षा करें।

यदि ईवेंट सेट है, तो तुरंत True लौटें। अन्यथा तब तक ब्लॉक करें जब तक कि कोई अन्य कार्य set()

set()

घटना सेट करें।

ईवेंट के सेट होने की प्रतीक्षा करने वाले सभी कार्यों को तुरंत जागृत किया जाएगा।

clear()

घटना स्पष्ट (परेशान)।

प्रतीक्षा पर wait() टास्क wait() अब तब तक ब्लॉक रहेंगे जब तक कि set() विधि को फिर से नहीं कहा जाता है।

is_set()

ईवेंट सेट होने पर वापस लौटें।

शर्त

class asyncio.Condition(lock=None, *, loop=None)

एक शर्त वस्तु। धागा-सुरक्षित नहीं।

किसी कार्य के घटित होने की प्रतीक्षा करने और फिर किसी साझा संसाधन के लिए अनन्य पहुँच प्राप्त करने के लिए किसी कार्य द्वारा असिनसियो स्थिति आदिम का उपयोग किया जा सकता है।

संक्षेप में, एक शर्त वस्तु एक Event और एक Lock की कार्यक्षमता को जोड़ती है। यह संभव है कि कई स्थिति वाले ऑब्जेक्ट एक लॉक साझा करें, जो उस साझा संसाधन के विशेष राज्यों में रुचि रखने वाले विभिन्न कार्यों के बीच एक साझा संसाधन के लिए विशेष पहुंच को समन्वयित करने की अनुमति देता है।

वैकल्पिक लॉक तर्क Lock ऑब्जेक्ट या None होना चाहिए। उत्तरार्द्ध मामले में एक नया लॉक ऑब्जेक्ट स्वचालित रूप से बनाया जाता है।

किसी शर्त का उपयोग करने का पसंदीदा तरीका कथन के async with एक async with :

cond = asyncio.Condition()

# ... later
async with cond:
    await cond.wait()

जो इसके बराबर है:

cond = asyncio.Condition()

# ... later
await lock.acquire()
try:
    await cond.wait()
finally:
    lock.release()
coroutine acquire()

अंतर्निहित लॉक को प्राप्त करें।

यह विधि प्रतीक्षा करती है जब तक कि अंतर्निहित लॉक अनलॉक नहीं हो जाता है , इसे लॉक पर सेट करता है और True लौटाता है।

notify(n=1)

इस स्थिति की प्रतीक्षा कर रहे अधिकांश n कार्यों (डिफ़ॉल्ट रूप से 1) पर जागें। यदि कोई कार्य प्रतीक्षा नहीं कर रहा है, तो विधि नो-ऑप है।

इस पद्धति को कॉल करने और कुछ समय बाद जारी करने से पहले लॉक को अधिग्रहित किया जाना चाहिए। यदि अनलॉक किए गए लॉक के साथ कॉल किया जाता है, तो RuntimeError त्रुटि उठाई जाती है।

locked()

यदि अंतर्निहित लॉक अधिग्रहित है तो True लौटें।

notify_all()

इस अवस्था में प्रतीक्षा करने वाले सभी कार्य करें।

यह विधि notify() तरह काम करती है, लेकिन सभी प्रतीक्षा कार्यों को पूरा करती है।

इस पद्धति को कॉल करने और कुछ समय बाद जारी करने से पहले लॉक को अधिग्रहित किया जाना चाहिए। यदि अनलॉक किए गए लॉक के साथ कॉल किया जाता है, तो RuntimeError त्रुटि उठाई जाती है।

release()

अंतर्निहित लॉक जारी करें।

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

coroutine wait()

अधिसूचित होने तक प्रतीक्षा करें।

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

यह विधि अंतर्निहित लॉक को रिलीज़ करती है, और तब तक ब्लॉक करती है जब तक कि यह एक notify_all() या notify_all() कॉल द्वारा जागृत न हो notify_all() । एक बार जागृत होने पर, स्थिति अपने लॉक को फिर से प्राप्त कर लेती है और यह विधि True रिटर्न करती है।

coroutine wait_for(predicate)

प्रतीक्षा करें जब तक कि एक विधेय सच नहीं हो जाता।

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

सिकंदरा

class asyncio.Semaphore(value=1, *, loop=None)

एक सेमाफोर वस्तु। धागा-सुरक्षित नहीं।

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

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

सेमाफोर का उपयोग करने का पसंदीदा तरीका कथन के async with एक async with :

sem = asyncio.Semaphore(10)

# ... later
async with sem:
    # work with shared resource

जो इसके बराबर है:

sem = asyncio.Semaphore(10)

# ... later
await sem.acquire()
try:
    # work with shared resource
finally:
    sem.release()
coroutine acquire()

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

यदि आंतरिक काउंटर शून्य से अधिक है, तो इसे एक से घटाएं और True तुरंत वापस करें। यदि यह शून्य है, तो release() तक प्रतीक्षा करें release() कहा जाता है और True वापस लौटें।

locked()

True अगर अर्धकुंभ तुरंत हासिल नहीं किया जा सकता है।

release()

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

BoundedSemaphore विपरीत, Semaphore BoundedSemaphore release() कॉल की तुलना में अधिक release() कॉल acquire() अनुमति देता है।

BoundedSemaphore

class asyncio.BoundedSemaphore(value=1, *, loop=None)

एक बंधी हुई अर्धमात्रा वस्तु। धागा-सुरक्षित नहीं।

बाउंडेड सेमाफोर, सेमाफोर का एक संस्करण है, जो release() में मान को बढ़ाता है release() अगर यह प्रारंभिक मूल्य से ऊपर आंतरिक काउंटर को बढ़ाता है।

संस्करण 3.7 के बाद से पदावनत: लॉक लॉक का उपयोग करके लॉक प्राप्त करना या await lock से yield from lock और / या स्टेटमेंट ( with await lock के with (yield from lock) , with (yield from lock) ) के साथ पदावनत है। इसके बजाय async with lock उपयोग करें।