पायथन शब्दकोश धागा सुरक्षित है?

Question

कुछ ने कहा कि पायथन शब्दकोश धागा सुरक्षित है। क्या इसका मतलब यह है कि मैं इसे फिर से चालू करते समय किसी शब्दकोश में आइटम्स को संशोधित या संशोधित नहीं कर सकता?

Answer 1

दो अवधारणाएं पूरी तरह से अलग हैं। Thread safety का अर्थ है कि दो थ्रेड एक ही ऑब्जेक्ट को एक ही समय में संशोधित नहीं कर सकते हैं, जिससे सिस्टम को असंगत स्थिति में छोड़ दिया जा सकता है।

उस ने कहा, आप इसे फिर से चालू करते समय एक शब्दकोश को संशोधित नहीं कर सकते हैं। documentation. देखें।

शब्दकोश पी को पुनरावृत्ति के दौरान उत्परिवर्तित नहीं किया जाना चाहिए। यह सुरक्षित है (चूंकि पायथन 2.1) से कुंजीपटल पर पुनरावृत्ति के रूप में कुंजी के मानों को संशोधित करता है, लेकिन केवल कुंजी सेट के रूप में परिवर्तित नहीं होता है।

Answer 2

नहीं। पाइथन का हालिया संस्करण अपवाद उठाएगा यदि आप एक शब्दकोश में पुनरावृत्ति करने का प्रयास करते हैं जो पुनरावृत्तियों के बीच आकार बदल गया है।

>>> d={'one':1, 'two':2} 
>>> for x in d: 
... d['three']=3 
... print x 
... 
two 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
RuntimeError: dictionary changed size during iteration 

सूचना है कि आप धागे का उपयोग करने के लिए इस

Answer 3

अन्य उत्तर पहले से ही सही ढंग से संबोधित क्या जाहिरा तौर पर अपने वास्तविक सवाल है यह देखने के लिए की जरूरत नहीं है:

तो इसका मतलब यह है कि मैं या संशोधित नहीं कर सकते हैं कर सकते हैं एक शब्दकोश में आइटम जबकि इसे फिर से शुरू कर रहा है?

कि धागा सुरक्षा के बारे में समझाकर मुद्दा, और किसी भी मामले में कोई लेना देना नहीं है, नहीं, आप एक dict इस पर पुनरावृत्ति करते हुए संशोधित नहीं कर सकते।

हालांकि, अपने प्रश्न के शीर्षक धागा सुरक्षा के बारे में है, और आप के साथ शुरू:

कुछ कहा गया है कि अजगर शब्दकोश धागा सुरक्षित

मैं कौन नहीं जानता है "कुछ" हैं, लेकिन, अगर उन्होंने यह कहा कि (जैसा कि आपने राज्य की स्थिति को गलत समझाया है ;-) बिना भारी योग्यता के, वे गलत हैं।

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

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

हालांकि, एक ऑपरेशन जैसे d[k] += 1 (यह मानते हुए कश्मीर पहले से मौजूद था, और इसके मूल्य एक नंबर) नहीं ठीक से सुरक्षित धागा बोल है (किसी अन्य की तुलना में अधिक += के मामले!) क्योंकि यह d[k] = d[k] + 1 के रूप में देखा जा सकता है - - यह हो सकता है ऐसा होता है कि दौड़ की स्थिति में दो धागे दोनों d[k] के पुराने मान को पढ़ते हैं, फिर इसे एक से बढ़ाते हैं, और स्लॉट में वही नया मान संग्रहीत करते हैं ... इसलिए समग्र प्रभाव केवल एक करके इसे बढ़ाना है , और सामान्य रूप से दो के रूप में नहीं होगा।

अपने अन्य प्रश्न पर वापस जाएं ... "केवल पढ़ने", "और जो कि पहले से ही तानाशाह में मौजूद कुंजी के लिए नए मान निर्दिष्ट करते हैं, वे चीजें हैं जो आप लूप के शरीर में कर सकते हैं ताना - आप निर्देश में कुंजियों के सेट को नहीं बदल सकते हैं (आप कोई भी कुंजी नहीं जोड़ सकते हैं, न ही किसी भी कुंजी को हटा सकते हैं), लेकिन मौजूदा कुंजी के लिए एक नया मान सेट करने के विशिष्ट संचालन की अनुमति है। इस मामले में अनुमत संचालन में += शामिल है जो थ्रेडिंग स्थिति में समस्याग्रस्त होगा। उदाहरण के लिए:

>>> d = dict.fromkeys(range(5), 0) 
>>> for k in d: d[k] += 1 
... 
>>> d 
{0: 1, 1: 1, 2: 1, 3: 1, 4: 1} 

और इस व्यवहार पायथन के मानकीकृत अर्थ विज्ञान द्वारा की गारंटी है, इसलिए भाषा के विभिन्न कार्यान्वयन सभी इसे संरक्षित करना चाहिए।