दिलचस्प पोस्ट
एच एच: एमएम: एसएस प्रारूप में केवल समय के लिए समय कन्वर्ट? बाश में $ PATH चर में पथ को हटाने का सबसे शानदार तरीका क्या है? फेसबुक की एपीआई का उपयोग करते हुए उपयोगकर्ता को मेरे फेसबुक पेज या यूआरएल को पसंद करने की जांच कैसे करें कार्यक्षमता की तरह precompiler निर्देश प्राप्त करने के लिए LINQ एकल बनाम पहले जीआईटी के साथ चेरी को चुनने का क्या मतलब है? MySQL, नल या रिक्त स्ट्रिंग को सम्मिलित करना बेहतर है? जावा हाशम की मेमोरी ओवरहेड ऐरेएलआईस्ट की तुलना में Matlab में एक फ़ोल्डर में फ़ाइलों के माध्यम से लूप JQuery के साथ एक फ़ोन नंबर को कैसे प्रारूपित करें एक SWF को एक WebView में लोड करें फ़ंक्शन के भीतर से ग्लोबल एएनवीवी को कई ऑब्जेक्ट सौंपें गुमनाम ऊर्जा का उपयोग एक .dex फ़ाइल में विधि संदर्भ की संख्या 64k एपीआई 17 से अधिक नहीं हो सकती प्रणाली ( "थामने"); – यह गलत क्यों है?

वास्तव में एक पुनरावृत्ति समारोह क्या है?

अधिकांश समय , रीएन्ट्रेंस की परिभाषा को विकिपीडिया से उद्धृत किया गया है :

एक कंप्यूटर प्रोग्राम या रूटीन को रीएन्ट्रन्ट के रूप में वर्णित किया गया है, यदि इसे अपने पहले अभिवादन पूरा होने से पहले इसे सुरक्षित रूप से बुलाया जा सकता है (यानी इसे समवर्ती रूप से सुरक्षित रूप से निष्पादित किया जा सकता है)। रीएन्ट्रंट होने के लिए, एक कंप्यूटर प्रोग्राम या रूटीन:

  1. कोई स्थैतिक (या वैश्विक) गैर-स्थिर डेटा अवश्य रखें
  2. पते को स्थैतिक (या वैश्विक) गैर-निरंतर डेटा में वापस नहीं करना चाहिए
  3. केवल कॉलर द्वारा प्रदान किए गए डेटा पर काम करना चाहिए।
  4. सिंगलटन संसाधनों के लिए लॉक पर निर्भर नहीं होना चाहिए।
  5. अपने स्वयं के कोड को संशोधित न करें (जब तक कि अपने स्वयं के अनूठे थ्रेड संग्रहण में निष्पादित न करें)
  6. गैर-रीएन्ट्रंट कंप्यूटर प्रोग्राम या रूटीन को कॉल नहीं करना चाहिए।

कैसे सुरक्षित रूप से परिभाषित किया जाता है?

अगर एक कार्यक्रम को एक साथ सुरक्षित रूप से निष्पादित किया जा सकता है , क्या इसका हमेशा मतलब है कि यह रीएन्ट्रेंट है?

छह अंकों के बीच क्या आम धागा है, यह उल्लेख किया गया है कि मेरे कोड को रीएन्ट्रंट क्षमताओं के लिए जाँचते वक्त मुझे ध्यान रखना चाहिए?

इसके अलावा,

  1. क्या सभी रिकेंटिव फ़ंक्शन रीएन्ट्रंट हैं?
  2. क्या सभी धागा-सुरक्षित कार्य रीएन्ट्रंट हैं?
  3. क्या सभी पुनरावर्ती और धागा-सुरक्षित कार्य रीएन्ट्रंट हैं?

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

Solutions Collecting From Web of "वास्तव में एक पुनरावृत्ति समारोह क्या है?"

1. कैसे सुरक्षित रूप से परिभाषित किया गया है?

शब्दार्थ। इस मामले में, यह एक कठिन परिभाषित शब्द नहीं है। इसका मतलब यह है कि "आप जोखिम के बिना ऐसा कर सकते हैं"

2. अगर किसी कार्यक्रम को एक साथ सुरक्षित रूप से निष्पादित किया जा सकता है, क्या इसका हमेशा इसका मतलब है कि यह रीएन्ट्रेंट है?

नहीं।

उदाहरण के लिए, चलो एक C ++ फ़ंक्शन है जो एक लॉक और पैरामीटर के रूप में एक कॉलबैक दोनों लेता है:

typedef void (*MyCallback)() ; NonRecursiveMutex mutex ; void myFunction(MyCallback f) { lock(mutex) ; f() ; unlock(mutex) ; } 

पहली नजर में, यह समारोह ठीक लगता है … लेकिन प्रतीक्षा करें:

 int main(int argc, char * argv[]) { myFunction(myFunction) ; return 0 ; } 

अगर म्यूटक्स पर लॉक पुनरावर्ती नहीं होता है, तो यहाँ क्या होगा:

  1. main myFunction कॉल myFunction
  2. myFunction ताला अधिग्रहण करेगा
  3. myFunction को फोन myFunction
  4. दूसरा myFunction लॉक अधिग्रहण करने का प्रयास करेगा, असफल हो जायेगा और इसे जारी होने के लिए प्रतीक्षा करनी होगी
  5. गतिरोध।
  6. ओह …

ठीक है, मैंने धोखा दिया, कॉलबैक चीज़ का उपयोग कर लेकिन समान प्रभाव वाले कोड के अधिक जटिल टुकड़ों की कल्पना करना आसान है।

3. छह अंकों के बीच आम धागा क्या है, उल्लेख किया गया है कि मुझे अपने कोड को रीएन्ट्रेंट क्षमताओं के लिए जाँच कर रखना चाहिए?

यदि आपके फ़ंक्शन में / परिवर्तनशील स्थायी संसाधनों तक पहुंच प्राप्त करने के लिए / या किसी ऐसे समारोह तक पहुंच की अनुमति देता है, जो आपको बदबू आ रही है तो आप एक समस्या की गंध कर सकते हैं

( ठीक है, हमारे 99% कोड को गंध चाहिए, फिर … इसे संभालने के लिए पिछले अनुभाग देखें … )

इसलिए, अपना कोड पढ़ना, उनमें से एक बिंदु आपको सतर्क होना चाहिए:

  1. समारोह में एक राज्य होता है (यानी एक वैश्विक चर, या यहां तक ​​कि एक क्लास सदस्य चर का उपयोग)
  2. इस फंक्शन को कई धागे से बुलाया जा सकता है, या स्टैक में दो बार दिखाई दे सकता है, जबकि प्रक्रिया निष्पादित हो रही है (यानी फ़ंक्शन स्वयं, सीधे या अप्रत्यक्ष रूप से कह सकता है)। मापदंडों के रूप में कॉलबैक लेना फंक्शन बहुत गंध करता है

ध्यान दें कि गैर-रिएन्ट्रैन्सी वायरल है: एक ऐसा समारोह जो संभवत: गैर-रीएन्ट्रंट फ़ंक्शन को कॉल कर सकता है, को रीएन्ट्रन्ट नहीं माना जा सकता है।

यह भी ध्यान रखें, कि सी ++ तरीके गंध क्योंकि उन्हें इस तक पहुंच है, इसलिए आपको कोड का अध्ययन करना चाहिए ताकि this सुनिश्चित किया जा सके कि उनके पास कोई मजेदार बातचीत नहीं है।

4.1। क्या सभी रिकेंटिव फ़ंक्शन रीएन्ट्रंट हैं?

नहीं।

मल्टीथ्रेड किए गए मामलों में, साझा संसाधनों तक पहुंचने वाली एक रिकर्सिव फ़ंक्शन एक ही समय में कई थ्रेडों द्वारा बुलाया जा सकता है, जिसके परिणामस्वरूप खराब / भ्रष्ट डेटा हो सकता है

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

4.2। क्या सभी धागा-सुरक्षित कार्य रीएन्ट्रंट हैं?

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

4.3। क्या सभी पुनरावर्ती और धागा-सुरक्षित कार्य रीएन्ट्रंट हैं?

मैं "हाँ" कहूँगा अगर "रिकर्सिव" द्वारा आप का मतलब "पुनरावर्ती-सुरक्षित" होगा

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

समस्या इस गारंटी का मूल्यांकन कर रही है … ^ _ ^

5. क्या ये नियम हैं जैसे रीएन्ट्रेंस और धागा सुरक्षा बिल्कुल पूर्ण है यानी उन्होंने ठोस परिभाषा तय की है?

मेरा मानना ​​है कि उनके पास है, लेकिन फिर, फ़ंक्शन का मूल्यांकन धागा-सुरक्षित या रीएन्ट्रेंट कठिन हो सकता है यही कारण है कि मैंने ऊपर की गंध का इस्तेमाल किया है: आप पा सकते हैं कि फ़ंक्शन रीएन्ट्रंट नहीं है, लेकिन यह सुनिश्चित करना मुश्किल हो सकता है कि कोड का एक जटिल भाग रीएन्ट्रेंट है

6. एक उदाहरण

मान लीजिए कि आपके पास एक ऐसा तरीका है, जिसमें संसाधनों का उपयोग करने की आवश्यकता है:

 struct MyStruct { P * p ; void foo() { if(this->p == NULL) { this->p = new P() ; } // Lots of code, some using this->p if(this->p != NULL) { delete this->p ; this->p = NULL ; } } } ; 

पहली समस्या यह है कि अगर किसी तरह इस फ़ंक्शन को रिकर्सिव कहा जाता है (यानी यह फ़ंक्शन सीधे या अप्रत्यक्ष रूप से कॉल करता है), कोड संभवत: क्रैश हो जाएगा, क्योंकि this->p अंतिम कॉल के अंत में हटा दिया जाएगा, और अभी भी शायद पहली कॉल के अंत से पहले इस्तेमाल किया

इस प्रकार, यह कोड रिकर्सिव-सुरक्षित नहीं है

हम इसे सही करने के लिए संदर्भ काउंटर का उपयोग कर सकते हैं:

 struct MyStruct { size_t c ; P * p ; void foo() { if(c == 0) { this->p = new P() ; } ++c ; // Lots of code, some using this->p --c ; if(c == 0) { delete this->p ; this->p = NULL ; } } } ; 

इस प्रकार, कोड पुनरावर्ती-सुरक्षित हो जाता है … लेकिन मल्टीथ्रेडिंग मुद्दों के कारण यह अभी भी नहीं है: हमें यकीन होना चाहिए कि c और p के संशोधनों को एक पुनरावर्ती म्यूटिक्स का उपयोग करके परमाणु रूप से किया जाएगा (सभी म्यूटक्स रिकर्सिव नहीं हैं) :

 struct MyStruct { mutex m ; // recursive mutex size_t c ; P * p ; void foo() { lock(m) ; if(c == 0) { this->p = new P() ; } ++c ; unlock(m) ; // Lots of code, some using this->p lock(m) ; --c ; if(c == 0) { delete this->p ; this->p = NULL ; } unlock(m) ; } } ; 

और ज़ाहिर है, यह सब मानता है कि lots of code स्वयं रीवेंट्रंट हैं, जिसमें p का उपयोग भी शामिल है।

और ऊपर दिए गए कोड भी दूर अपवाद-सुरक्षित नहीं हैं , लेकिन यह एक और कहानी है … ^ _ ^

7. हमारे कोड का 99% रीएन्ट्रंट नहीं है !!

स्पेगेटी कोड के लिए यह काफी सच है लेकिन अगर आप सही तरीके से अपने कोड का विभाजन करते हैं, तो आप रिएन्ट्रैन्सी समस्याओं से बचेंगे।

7.1। सुनिश्चित करें कि सभी कार्यों में कोई राज्य नहीं है।

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

7.2। सुनिश्चित करें कि आपका ऑब्जेक्ट "पुनरावर्ती-सुरक्षित" है

किसी ऑब्जेक्ट विधि का यह उपयोग होता है, इसलिए यह ऑब्जेक्ट के एक ही उदाहरण के सभी तरीकों के साथ एक राज्य साझा करता है।

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

7.3। सुनिश्चित करें कि आपकी सभी वस्तुओं को सही ढंग से समझाया गया हो।

किसी और को अपने आंतरिक डेटा तक पहुंच नहीं होनी चाहिए:

  // bad int & MyObject::getCounter() { return this->counter ; } // good int MyObject::getCounter() { return this->counter ; } // good, too void MyObject::getCounter(int & p_counter) { p_counter = this->counter ; } 

यहां तक ​​कि एक संदर्भ संदर्भ भी खतरनाक हो सकता है यदि उपयोग डेटा के पते को प्राप्त करता है, क्योंकि कोड के कुछ अन्य भाग को कॉन्फ़ेन्टेड संदर्भ संहिता को पकड़ने के बिना संशोधित किया जा सकता है।

7.4। सुनिश्चित करें कि उपयोगकर्ता जानता है कि आप ऑब्जेक्ट धागा-सुरक्षित नहीं हैं

इस प्रकार, उपयोगकर्ता थ्रेड के बीच साझा ऑब्जेक्ट का उपयोग करने के लिए म्यूटक्स का उपयोग करने के लिए ज़िम्मेदार है।

एसटीएल की वस्तुओं को थ्रेड-सुरक्षित (प्रदर्शन संबंधी मुद्दों की वजह से) नहीं बनाया गया है, और इस प्रकार, यदि कोई उपयोगकर्ता दो धागे के बीच std::string को साझा करना चाहता है, तो उपयोगकर्ता को संगामी primitives के साथ अपनी पहुंच की रक्षा करनी चाहिए;

7.5। सुनिश्चित करें कि आप थ्रेड-सुरक्षित कोड पुनरावर्ती-सुरक्षित है

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

"सुरक्षित रूप से" को सामान्य ज्ञान के रूप में परिभाषित किया गया है – इसका अर्थ है "अन्य चीजों के बिना दखल के बिना अपनी बात सही ढंग से कर रहा है" छह अंक जो आप स्पष्ट रूप से उद्धृत करते हैं, उनको हासिल करने के लिए आवश्यकताओं को स्पष्ट रूप से व्यक्त करें।

आपके 3 प्रश्नों के उत्तर 3 × "नहीं" हैं


क्या सभी रिकेंटिव फ़ंक्शन रीएन्ट्रंट हैं?

नहीं!

पुनरावर्ती समारोह के दो साथ-साथ आविष्कार आसानी से एक दूसरे को पेंच कर सकते हैं, उदाहरण के लिए, यदि वे एक ही वैश्विक / स्थिर डेटा तक पहुंचते हैं।


क्या सभी धागा-सुरक्षित कार्य रीएन्ट्रंट हैं?

नहीं!

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


क्या सभी पुनरावर्ती और धागा-सुरक्षित कार्य रीएन्ट्रंट हैं?

नहीं!

ऊपर देखो।

सामान्य धागा:

क्या यह व्यवहार अच्छी तरह से परिभाषित है यदि रूटीन को बाधित होने पर कहा जाता है?

यदि आपके पास ऐसा फ़ंक्शन है:

 int add( int a , int b ) { return a + b; } 

तो यह किसी भी बाहरी राज्य पर निर्भर नहीं है व्यवहार अच्छी तरह से परिभाषित है।

यदि आपके पास ऐसा फ़ंक्शन है:

 int add_to_global( int a ) { return gValue += a; } 

परिणाम कई धागे पर अच्छी तरह से परिभाषित नहीं है। यदि समय गलत था तो सूचना खो सकती है

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

अब मुझे मेरी पिछली टिप्पणी पर विस्तार करना होगा। @पैसासबल का जवाब गलत है उदाहरण के कोड में किसी ने ध्यान नहीं दिया कि म्यूटक्स जो पैरामीटर मानता था वास्तव में पारित नहीं किया गया था?

मैं निष्कर्ष पर विवाद करता हूं, मैं कहता हूं: संगामिति की उपस्थिति में एक समारोह को सुरक्षित रखने के लिए इसे पुन: प्रवेश होना चाहिए। इसलिए समवर्ती-सुरक्षित (आमतौर पर लिखे धागे-सुरक्षित) का अर्थ है पुन: प्रवेशकर्ता

न तो धागे सुरक्षित और पुनः प्रवेश करने वाले के तर्कों के बारे में कुछ भी कहना है: हम फ़ंक्शन के समवर्ती निष्पादन के बारे में बात कर रहे हैं, जो अनुपयुक्त मापदंडों का उपयोग किया जाता है, फिर भी असुरक्षित हो सकता है।

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

यह समझना महत्वपूर्ण है कि सामान्य तौर पर थ्रेड-सेफ़ ऑपरेशन में पैरामीटर शामिल हैं। यदि आपने कोई डेटाबेस प्रोग्रामिंग किया है, तो आप समझेंगे। "परमाणु" क्या है और इसे म्यूट एक्स या कुछ अन्य तकनीक द्वारा संरक्षित किया जा सकता है, यह अवधारणा एक उपयोगकर्ता अवधारणा है: एक डेटाबेस पर लेनदेन के क्रियान्वयन के लिए कई अन-बाधित संशोधनों की आवश्यकता हो सकती है कौन कह सकता है कि कौन सी लोगों को सिंक में रखा जाना चाहिए, लेकिन क्लाइंट प्रोग्रामर?

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

वहाँ कई प्रोग्रामिंग सिस्टम हैं: ओककल एक है, और मुझे लगता है कि पायथन भी है, जिसमें बहुत सारे गैर-रीएन्ट्रेंट कोड हैं, लेकिन जो थ्रेड एसेसेस को दबाने के लिए एक वैश्विक लॉक का उपयोग करता है ये सिस्टम पुन: प्रवेश नहीं कर रहे हैं और वे थ्रेड-सुरक्षित या समवर्ती-सुरक्षित नहीं हैं, वे सुरक्षित रूप से संचालित करते हैं क्योंकि वे वैश्विक स्तर पर संगामिति को रोकते हैं

एक अच्छा उदाहरण malloc है यह फिर से प्रवेश नहीं है और धागा-सुरक्षित नहीं है। इसका कारण यह है कि उसे एक वैश्विक संसाधन (ढेर) तक पहुंचाना है। तालों का उपयोग करना सुरक्षित नहीं बनाता: यह निश्चित रूप से पुनः प्रवेश नहीं है यदि इंटरफ़ेस को malloc ठीक से डिजाइन किया गया था तो इसे पुनः प्रवेश करने और धागा-सुरक्षित बनाने संभव होगा:

 malloc(heap*, size_t); 

अब यह सुरक्षित हो सकता है क्योंकि यह ग्राहक को एक ही ढेर तक साझा अभिगम के लिए serialising की ज़िम्मेदारी स्थानांतरित करता है। अलग-अलग हेप ऑब्जेक्ट्स हैं, विशेष रूप से कोई कार्य आवश्यक नहीं है। यदि एक सामान्य ढेर का उपयोग किया जाता है, तो ग्राहक को एक्सेस की धारावाहिक होना चाहिए। फ़ंक्शन के अंदर एक लॉक का उपयोग करना पर्याप्त नहीं है: बस एक मॉलोक को ढेर के तालाबंदी * पर विचार करें और फिर एक संकेत के साथ आता है और एक ही पॉइंटर पर मॉलोक को कॉल करता है: डेडलॉक: सिग्नल आगे नहीं बढ़ सकता है, और क्लाइंट या तो नहीं कर सकता क्योंकि बाधित है

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

सूचीबद्ध अंकों के बीच "सामान्य धागा" (यमक!!?) यह है कि फ़ंक्शन किसी भी ऐसा काम नहीं करना चाहिए जो किसी भी रिकर्सिव या समवर्ती कॉल के व्यवहार को उसी फ़ंक्शन पर प्रभावित करे।

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

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

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

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

आपके "इसके अलावा" सवालों के जवाब "नहीं", "नहीं" और "नहीं" हैं। सिर्फ इसलिए कि एक फ़ंक्शन रिकर्सिव और / या थ्रेड सुरक्षित है, वह इसे फिर से प्रवेश नहीं करता है

इन सभी प्रकार के फ़ंक्शन, आपके द्वारा उद्धृत सभी बिंदुओं पर विफल हो सकते हैं। (हालांकि मैं बिंदु 5 के कुछ 100% नहीं हूं)।

"थ्रेड-सुरक्षित" और "पुनःप्रवेश" शब्द का अर्थ केवल वही है जो उनकी परिभाषाओं को कहते हैं इस संदर्भ में "सुरक्षित" का मतलब केवल इसका अर्थ है कि नीचे दी गई परिभाषा क्या कहते हैं।

निश्चित रूप से "सुरक्षित" का मतलब व्यापक रूप से सुरक्षित नहीं है कि किसी दिए गए संदर्भ में किसी दिए गए फ़ंक्शन को बुलाए जाने से आपके आवेदन पूरी तरह से नल नहीं होगा। कुल मिलाकर, एक फ़ंक्शन आपके बहु-थ्रेडेड एप्लिकेशन में एक वांछित प्रभाव को मज़बूती से उत्पन्न कर सकता है, लेकिन परिभाषा के अनुसार पुन: प्रवेश या धागा-सुरक्षित के रूप में योग्य नहीं है। सामने से, आप फिर से प्रवेश करने वाले कार्यों को उन तरीकों में बुला सकते हैं जो आपके बहु-थ्रेडेड एप्लिकेशन में कई अवांछित, अप्रत्याशित और / या अप्रत्याशित प्रभाव उत्पन्न करेंगे।

रिकर्सिव फ़ंक्शन कुछ भी हो सकता है और पुनः प्रवेशकर्ता को धागा-सुरक्षित की तुलना में एक मजबूत परिभाषा होती है, इसलिए आपके नंबर वाले प्रश्नों के उत्तर सभी नहीं होते हैं।

फिर से प्रवेश की परिभाषा पढ़ना, कोई भी इसे एक समारोह के रूप में संक्षेप में प्रस्तुत कर सकता है जो कि आप इसे संशोधित करने के लिए कहने से परे किसी भी चीज़ को संशोधित नहीं करेंगे। लेकिन आपको केवल सारांश पर भरोसा नहीं करना चाहिए

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