क्या यह पायथन निर्माता-उपभोक्ता लॉकलेस दृष्टिकोण थ्रेड-सुरक्षित है?

Question

मैंने हाल ही में एक कार्यक्रम लिखा है जो एक साधारण निर्माता/उपभोक्ता पैटर्न का उपयोग करता है। शुरुआत में इसे थ्रेडिंग के अनुचित उपयोग से संबंधित एक बग था। लॉक कि मैंने अंततः तय किया। लेकिन इससे मुझे लगता है कि निर्माता/उपभोक्ता पैटर्न को लॉकलेस तरीके से कार्यान्वित करना संभव है या नहीं।

• एक निर्माता धागा: मेरे मामले में

  आवश्यकताओं सरल थे।

• एक उपभोक्ता धागा।
• कतार केवल एक आइटम के लिए स्थान नहीं है।
• निर्माता अगले आइटम से पहले मौजूदा एक सेवन किया जाता है उत्पादन कर सकते हैं। इसलिए वर्तमान आइटम खो गया है, लेकिन यह मेरे लिए ठीक है।
• उपभोक्ता वर्तमान आइटम उपभोग कर सकते हैं इससे पहले कि अगले एक का उत्पादन किया है। इसलिए वर्तमान वस्तु को दो बार (या अधिक) खपत किया जाता है, लेकिन यह मेरे लिए ठीक है।

तो मैं यह लिखा:

QUEUE_ITEM = None 

# this is executed in one threading.Thread object 
def producer(): 
    global QUEUE_ITEM 
    while True: 
     i = produce_item() 
     QUEUE_ITEM = i 

# this is executed in another threading.Thread object 
def consumer(): 
    global QUEUE_ITEM 
    while True: 
     i = QUEUE_ITEM 
     consume_item(i) 

मेरे सवाल यह है: इस कोड को धागे की सुरक्षित है?

तत्काल टिप्पणी: इस कोड को वास्तव में नहीं है लॉकसेल - मैं CPython उपयोग करें और यह जीआईएल है।

मैं कोड एक छोटे से परीक्षण किया है और यह काम करने लगता है। यह कुछ लोड और स्टोर ओप में अनुवाद करता है जो जीआईएल के कारण परमाणु हैं। लेकिन मुझे यह भी पता है कि del x ऑपरेशन परमाणु नहीं है जब x __del__ विधि लागू करता है। तो अगर मेरे आइटम में __del__ विधि है और कुछ बुरा शेड्यूलिंग होता है, तो चीजें तोड़ सकती हैं। या नहीं?

एक और सवाल यह है कि: किस तरह के प्रतिबंध (उदाहरण के लिए उत्पादित वस्तुओं के प्रकार पर) उदाहरण के लिए मुझे ऊपर कोड को ठीक करने के लिए लगाया जाना चाहिए?

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

Answer 1

हाँ इस तरह से है कि आप वर्णित में काम करेंगे:

1. कि निर्माता स्किप करने योग्य तत्व हो सकता है।
2. कि उपभोक्ता एक ही तत्व का उपभोग कर सकता है।

लेकिन मैं यह भी जानता हूँ कि डेल एक्स आपरेशन परमाणु जब एक्स औजार डेल विधि नहीं है। तो अगर मेरे आइटम में डेल विधि है और कुछ बुरा शेड्यूलिंग होता है, तो चीजें तोड़ सकती हैं।

मुझे यहां "डेल" नहीं दिख रहा है। यदि कोई del delume_item में होता है तो del निर्माता थ्रेड में हो सकता है। मुझे नहीं लगता कि यह एक "समस्या" होगी।

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

Answer 2

इसका कारण यह है निर्माता QUEUE_ITEM के ऊपर लिख सकता है उपभोक्ता से पहले ही उपयोग किए गए और उपभोक्ता दो बार QUEUE_ITEM का उपभोग नहीं कर सका वास्तव में धागा सुरक्षित है। जैसा कि आपने बताया है, आप इसके साथ ठीक हैं लेकिन अधिकांश लोग नहीं हैं।

किसी को भी cpython internals के अधिक ज्ञान के साथ आपको अधिक सैद्धांतिक प्रश्नों का उत्तर देना होगा।

Answer 3

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

इसके अलावा धागे किसी भी संख्या को चलाने से पहले किसी भी संख्या का उत्पादन/उपभोग कर सकते हैं।

Answer 4

आप कतार के रूप में एक सूची का उपयोग तब तक कर सकते हैं जब तक कि आप दोनों परमाणु हैं क्योंकि आप संलग्न/पॉप करना चाहते हैं।

QUEUE = [] 

# this is executed in one threading.Thread object 
def producer(): 
    global QUEUE 
    while True: 
     i = produce_item() 
     QUEUE.append(i) 

# this is executed in another threading.Thread object 
def consumer(): 
    global QUEUE 
    while True: 
     try: 
      i = QUEUE.pop(0) 
     except IndexError: 
      # queue is empty 
      continue 

     consume_item(i) 

नीचे की तरह एक वर्ग के दायरे में, आप कतार को भी साफ़ कर सकते हैं।

class Atomic(object): 
    def __init__(self): 
     self.queue = [] 

    # this is executed in one threading.Thread object 
    def producer(self): 
     while True: 
      i = produce_item() 
      self.queue.append(i) 

    # this is executed in another threading.Thread object 
    def consumer(self): 
     while True: 
      try: 
       i = self.queue.pop(0) 
      except IndexError: 
       # queue is empty 
       continue 

      consume_item(i) 

    # There's the possibility producer is still working on it's current item. 
    def clear_queue(self): 
     self.queue = [] 

आपको यह पता लगाना होगा कि बाइटकोड जेनरेट करके आपको कौन सी सूची संचालन परमाणु है।

Answer 5

ट्रिकरी आपको काट देगा। थ्रेड के बीच संवाद करने के लिए बस कतार का उपयोग करें।

Answer 6

__del__ जैसा आपने कहा था एक समस्या हो सकती है। इससे बचा जा सकता है, अगर कचरा कलेक्टर को __del__ विधि को पुराने ऑब्जेक्ट पर विधि से पहले हम QUEUE_ITEM पर नया कार्य करने से पहले ही एक तरीका था। हमें कुछ की आवश्यकता होगी:

increase the reference counter on the old object 
assign a new one to `QUEUE_ITEM` 
decrease the reference counter on the old object 

मुझे डर है, मुझे नहीं पता कि यह संभव है या नहीं।