मैं यह पढ़ रहा था:
क्या निम्न फ़ंक्शन धागा-सुरक्षित है?
शून्य foo (int y) {int * x = नया int [50]; /..... आवंटित स्मृति के साथ कुछ सामान ... * / हटाएं [] x; } लेख में यह कहता है कि धागा-सुरक्षित होने के लिए आप केवल स्टैक से चर का उपयोग कर सकते हैं। वास्तव में? क्यूं कर? क्या उपर्युक्त कार्य के बाद वाले कॉलों को कहीं और स्मृति आवंटित नहीं करेंगे?
संपादित करें: आह ऐसा लगता है कि मैं इस लेख के इस भाग को गलत कहता हूं:
एक सब-रूटिन रीएन्ट्रेंट है, और इस प्रकार यह धागा-सुरक्षित है, अगर
- इसका इस्तेमाल करने वाले केवल चर यह हैं स्टैक
(मैं इसे
मतलब ले गया है एक सब-रूटिन रीएन्ट्रंट है, और इस प्रकार धागा-सुरक्षित है, अगर और केवल तभी
- इसका उपयोग करने वाले केवल चर स्टैक से हैं
, जो नीचे दिए गए उत्तरों के अनुसार, मामला नहीं है )
यदि आप वातावरण में कोडिंग कर रहे हैं जो बहु-थ्रेडिंग का समर्थन करता है, तो आप निश्चित रूप से सुनिश्चित हो सकते हैं < कोड> नया धागा सुरक्षित है।
यद्यपि मेमोरी ढेर पर है, यह सूचक स्टैक पर है। केवल आपके थ्रेड में इस मेमोरी का सूचक होता है, और इसलिए समवर्ती संशोधन का कोई खतरा नहीं है - कोई अन्य थ्रेड नहीं जानता है कि स्मृति को संशोधित करने के लिए कहां है।
आप केवल थ्रेड सुरक्षा के साथ एक समस्या प्राप्त करेंगे यदि आप इस पॉइंटर को दूसरे थ्रेड पर पास करना था, जो तब आपके मूल (या अन्य) थ्रेड के रूप में एक साथ इसी स्मृति को संसाधित करेगा।
Comments
Post a Comment