परमाणु और nonatomic विशेषताओं के बीच क्या अंतर है?

यह एप्पल के से समझाया गया है प्रलेखन , लेकिन नीचे क्या वास्तव में हो रहा है के कुछ उदाहरण हैं। नोट नहीं "परमाणु" कीवर्ड है कि वहाँ, यदि आप निर्दिष्ट नहीं "nonatomic" तो संपत्ति परमाणु है से संबंधित, लेकिन "परमाणु" स्पष्ट रूप से एक त्रुटि का परिणाम देगा।

//@property(nonatomic, retain) UITextField *userName;
//Generates roughly

- (UITextField *) userName {
    return userName;
}

- (void) setUserName:(UITextField *)userName_ {
    [userName_ retain];
    [userName release];
    userName = userName_;
}

अब, परमाणु संस्करण में थोड़ा और अधिक जटिल है:

//@property(retain) UITextField *userName;
//Generates roughly

- (UITextField *) userName {
    UITextField *retval = nil;
    @synchronized(self) {
        retval = [[userName retain] autorelease];
    }
    return retval;
}

- (void) setUserName:(UITextField *)userName_ {
    @synchronized(self) {
      [userName_ retain];
      [userName release];
      userName = userName_;
    }
}

असल में, परमाणु संस्करण वस्तु पर रेफरी गणना (और autorelease गिनती इसे संतुलित करने) ताकि वस्तु फोन करने वाले के लिए मौजूद गारंटी है जोड़ने से है धागा सुरक्षा की गारंटी करने के क्रम में एक ताला लेने के लिए है, और यह भी, अन्यथा अगर एक और धागा, मूल्य स्थापित कर रही है रेफरी गिनती 0 तक गिरने के कारण एक संभावित रेस स्थिति है।

वहाँ वास्तव में कैसे इन बातों गुण अदिश मूल्यों या वस्तुओं रहे हैं, इस आधार पर काम के अलग-अलग रूपों की एक बड़ी संख्या है, और कैसे बनाए रखने के लिए, प्रतिलिपि, केवल पढ़ने के लिए, nonatomic, आदि सहभागिता करते हैं। सामान्य तौर पर संपत्ति सिंथेसाइज़र कितना सभी संयोजनों के लिए "सही बात" करने के लिए पता है।

परमाणु

• डिफ़ॉल्ट व्यवहार है
• वर्तमान प्रक्रिया को सुनिश्चित करेगा सीपीयू द्वारा पूरा हो गया है, इससे पहले कि किसी अन्य प्रक्रिया चर तक पहुँचता है
• के रूप में यह सुनिश्चित करता है प्रक्रिया पूरी तरह से पूरा हो गया है नहीं, तेज है

गैर-परमाणु

• नहीं डिफ़ॉल्ट व्यवहार है
• तेजी से (संश्लेषित कोड के लिए, वह है, @property और @synthesize का उपयोग कर बनाई चर के लिए)
• नहीं धागा सुरक्षित
• अप्रत्याशित व्यवहार में हो सकता है, दो अलग अलग प्रक्रिया एक ही समय में एक ही चर तक पहुंचने देना

अंतर को समझने के लिए सबसे अच्छा तरीका निम्न उदाहरण का उपयोग कर रहा है।

मान लीजिए एक परमाणु स्ट्रिंग संपत्ति "नाम" कहा जाता है, और यदि आप फोन [self setName:@"A"]धागा एक से, फोन [self setName:@"B"]धागा बी से, और कॉल [self name]धागा सी से, तो अलग धागे पर सभी कार्यों अगर एक धागा एक सेटर निष्पादित हो रहा है जिसका मतलब है कि क्रमानुसार प्रदर्शन किया जाएगा या गेटर, तो अन्य धागे इंतजार करेंगे।

यह गुण "नाम" पढ़ने / सुरक्षित बारे में बनाता है, लेकिन अगर एक और धागा, डी, कॉल [name release]एक साथ तो इस कार्रवाई को एक दुर्घटना का उत्पादन हो सकता है कोई सेटर / गेटर कॉल यहां शामिल न होने के कारण। इसका मतलब है एक वस्तु पढ़ा जाता है / सुरक्षित लिखना (परमाणु), लेकिन थ्रेड-सुरक्षित नहीं के रूप में एक और सूत्र एक साथ वस्तु के लिए गए संदेशों के किसी भी प्रकार भेज सकते हैं। डेवलपर इस तरह की वस्तुओं के लिए धागे की सुरक्षा सुनिश्चित करनी चाहिए।

यदि संपत्ति "नाम" nonatomic था, तो ऊपर के उदाहरण में सभी धागे - ए, बी, सी और डी एक साथ किसी भी अप्रत्याशित परिणाम उत्पादन पर अमल होगा। परमाणु के मामले में, या तो ए, बी या सी से एक पहले अमल होगा, लेकिन विकास अभी भी समानांतर में निष्पादित कर सकते हैं।

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

इन 3 के बीच कार्यात्मक क्या अंतर है?

मैं हमेशा एक डिफ़ॉल्ट काफी उत्सुक के रूप में परमाणु माना जाता था। अमूर्त स्तर पर हम पर काम करते हैं, एक वाहन के रूप में एक वर्ग के लिए परमाणु गुणों का उपयोग करके 100% धागे की सुरक्षा प्राप्त करने के लिए पर एक कोने मामला है। सही मायने में सही बहु प्रोग्राम के लिए, प्रोग्रामर द्वारा हस्तक्षेप लगभग निश्चित रूप से एक आवश्यकता है। इस बीच, प्रदर्शन विशेषताओं और निष्पादन अभी तक गहराई में विस्तृत नहीं किया गया है। पिछले कुछ वर्षों में कुछ भारी बहु कार्यक्रमों लिखा, मैं के रूप में मेरे गुण घोषित कर दिया गया था nonatomicपूरे समय क्योंकि परमाणु भी प्रयोजन के लिए समझदार नहीं था। परमाणु और nonatomic गुण के विवरण की चर्चा के दौरान इस सवाल का , मैं कुछ रूपरेखा कुछ उत्सुक परिणाम का सामना करना पड़ा था।

क्रियान्वयन

ठीक। पहली बात मैं स्पष्ट करने के लिए चाहते हैं लॉकिंग कार्यान्वयन कार्यान्वयन से परिभाषित और निकाला गया है। लुई का उपयोग करता है @synchronized(self)अपने उदाहरण में - मैं भ्रम का एक आम स्रोत के रूप में इस देखा है। कार्यान्वयन नहीं है वास्तव में उपयोग करें @synchronized(self); यह वस्तु स्तर का उपयोग करता स्पिन ताले । लुई के चित्रण निर्माणों हम सभी परिचित हैं का उपयोग कर एक उच्च स्तरीय उदाहरण के लिए अच्छा है, लेकिन यह पता करने के लिए यह प्रयोग नहीं करता है के लिए महत्वपूर्ण है @synchronized(self)।

एक और अंतर यह है कि परमाणु गुण गेटर के भीतर अपनी वस्तुओं को बनाए रखने / रिलीज चक्र होगा।

प्रदर्शन

परमाणु संपत्ति का उपयोग कर प्रदर्शन में पहुँचता: यहाँ दिलचस्प हिस्सा है निर्विरोध (जैसे एकल पिरोया) मामलों कुछ मामलों में बहुत तेजी से वास्तव में हो सकता है। आदर्श से कम मामलों में, परमाणु पहुंच के उपयोग के 20 से अधिक बार की भूमि के ऊपर खर्च कर सकते हैं nonatomic। जबकि चुनाव लड़ा 7 धागे का उपयोग कर मामले तीन-बाइट struct (2.2 GHz के लिए 44 बार धीमी थी कोर i7 क्वाड कोर, x86_64)। तीन-बाइट struct एक बहुत ही धीमी गति से संपत्ति का एक उदाहरण है।

दिलचस्प ओर ध्यान दें: तीन-बाइट struct के उपयोगकर्ता-परिभाषित accessors संश्लेषित परमाणु accessors से 52 गुना तेजी से थे, या 84% संश्लेषित nonatomic accessors की गति।

चुनाव लड़ा मामलों में वस्तुओं भी 50 गुना अधिक हो सकती है।

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

तो चलो पीछे हटना, चलो नहीं संपत्ति के कार्यान्वयन पहुंचता है, तो हम जैसे सामान्य संदिग्धों शामिल करेंगे पर ध्यान केंद्रित objc_msgSendहै, और एक के लिए कई कॉल के लिए कुछ वास्तविक दुनिया उच्च स्तरीय परिणाम की जांच NSStringमें गेटर निर्विरोध मामलों (सेकंड में मान):

• एमआरसी | nonatomic | मैन्युअल रूप से लागू ही टिककर खेल: 2
• एमआरसी | nonatomic | संश्लेषित गेटर: 7
• एमआरसी | परमाणु | संश्लेषित गेटर: 47
• एआरसी | nonatomic | संश्लेषित गेटर: 38 (ध्यान दें: एआरसी के जोड़ने रेफरी गिनती यहां साइकिल चलाना)
• एआरसी | परमाणु | संश्लेषित गेटर: 47

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

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

परमाणु = धागा सुरक्षा

गैर-परमाणु = नहीं धागा सुरक्षा

थ्रेड सुरक्षा:

उदाहरण चर धागा सुरक्षित अगर वे ठीक से व्यवहार जब एक से अधिक थ्रेड तक पहुंच कर, समय-निर्धारण या क्रम पर्यावरण से उन धागे के निष्पादन के इंटरलिविंग की परवाह किए बिना, और बुला कोड की ओर से कोई अतिरिक्त तुल्यकालन या अन्य समन्वय के साथ कर रहे हैं।

हमारे संदर्भ में:

एक सूत्र के उदाहरण का मूल्य बदलता है, तो बदली हुई मूल्य के लिए सभी धागे उपलब्ध है, और केवल एक धागा एक समय में मूल्य बदल सकते हैं।

कहाँ उपयोग करने के लिए atomic:

उदाहरण चर वाला एक बहु-क्रम वातावरण में पहुँचा जा रहा है।

के निहितार्थ atomic:

के रूप में जल्दी नहीं के रूप में nonatomicक्योंकि nonatomicक्रम से उस पर किसी भी प्रहरी काम की आवश्यकता नहीं है।

कहाँ उपयोग करने के लिए nonatomic:

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

मैं परमाणु और गैर-परमाणु संपत्तियों की एक बहुत अच्छी तरह से कर दिया स्पष्टीकरण पाया यहाँ । यहाँ एक ही से कुछ प्रासंगिक पाठ है:

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

प्रभाव में जिसका अर्थ है कि चर (रों) विधि द्वारा पढ़ा जा रहा तरह से के माध्यम से कुछ अन्य धागा / कॉल / समारोह हो जाता है क्योंकि उनके मूल्य आधा नहीं बदल सकते हैं - तो मैं अनुमान लगा इस मामले में परमाणु का मतलब है कि विशेषता पाठक तरीकों बाधित नहीं किया जा सकता हो जाएगा सीपीयू पर बदली।

क्योंकि atomicचर बाधित नहीं किया जा सकता है, किसी भी बिंदु पर उनके द्वारा निहित मूल्य (धागा ताला) होने की गारंटी है uncorrupted है, हालांकि, इस सूत्र ताला सुनिश्चित धीमी उन तक पहुंच बना देता है। non-atomicचर, दूसरे हाथ पर, ऐसी कोई गारंटी है, लेकिन जल्द पहुंच के लक्जरी प्रदान करते हैं। यह कुल मिलाकर, के साथ जाने के non-atomicलिए जब आप जानते हैं कि आपके चर एक साथ कई धागे और गति बातें द्वारा पहुँचा नहीं किया जाएगा।

इतने सारे लेख, स्टैक ओवरफ़्लो पोस्ट पढ़ और चर संपत्ति विशेषताओं की जांच डेमो आवेदन करने के बाद, मैं सभी विशेषताओं के बारे में जानकारी को एक साथ रखा करने का निर्णय लिया:

1. atomic // चूक
2. nonatomic
3. strong = retain // चूक
4. weak = unsafe_unretained
5. retain
6. assign // चूक
7. unsafe_unretained
8. copy
9. readonly
10. readwrite // चूक

लेख में चर संपत्ति गुण या iOS में संशोधक आप सभी उपर्युक्त गुण प्राप्त कर सकते हैं, और कहा कि निश्चित रूप से मदद मिलेगी।

1. atomic

   • atomic केवल एक ही धागे का उपयोग चर (स्थिर प्रकार) का मतलब है।
   • atomic सुरक्षित थ्रेड है।
   • लेकिन यह प्रदर्शन में धीमी है
   • atomic डिफ़ॉल्ट व्यवहार है
   • एक गैर कचरा एकत्र वातावरण में परमाणु accessors (यानी जब बनाए रखने / रिलीज / autorelease का प्रयोग करके) सुनिश्चित करना है कि एक और धागा / मूल्य की हो रही सही सेटिंग के साथ हस्तक्षेप नहीं करता है एक ताला का प्रयोग करेंगे।
   • यह वास्तव में एक शब्द नहीं है।
     
     

   उदाहरण:

       @property (retain) NSString *name;
   
       @synthesize name;
   

2. nonatomic

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

   उदाहरण:

       @property (nonatomic, retain) NSString *name;
   
       @synthesize name;
   

सबसे आसान जवाब पहले: वहाँ अपने दूसरे दो उदाहरण के बीच कोई अंतर नहीं है। डिफ़ॉल्ट रूप से, संपत्ति accessors परमाणु कर रहे हैं।

एक गैर कचरा एकत्र वातावरण में परमाणु accessors (यानी जब बनाए रखने / रिलीज / autorelease का प्रयोग करके) सुनिश्चित करना है कि एक और धागा / मूल्य की हो रही सही सेटिंग के साथ हस्तक्षेप नहीं करता है एक ताला का प्रयोग करेंगे।

"देखो प्रदर्शन और थ्रेडिंग जब मल्टी-थ्रेडेड ऐप्स बनाने के लिए कुछ और जानकारी के लिए और अन्य कारणों के लिए एप्पल के ऑब्जेक्टिव-सी 2.0 दस्तावेज के" खंड।

परमाणु:

है कि संपत्ति के लिए पहुँच परमाणु की गारंटी देता है एक परमाणु ढंग से प्रदर्शन किया जाएगा। उदाहरण के लिए यह हमेशा एक पूरी तरह से initialised वस्तुओं एक धागे पर एक संपत्ति के किसी भी प्राप्त / सेट लौटने के लिए, पहले एक और उस तक पहुँच सकते पूरा करना होगा।

आप निम्नलिखित समारोह में एक बार आप देख सकते हैं क्यों परिणाम सुंदर नहीं होगा दो धागे पर होने वाली कल्पना है।

-(void) setName:(NSString*)string
{
  if (name)
  {
    [name release]; 
    // what happens if the second thread jumps in now !?
    // name may be deleted, but our 'name' variable is still set!
    name = nil;
  }

  ...
}

पेशेवरों: पूरी तरह से initialised वस्तुओं की वापसी हर बार यह बहु सूत्रण के मामले में सबसे अच्छा विकल्प बनाता है।

विपक्ष: प्रदर्शन हिट, थोड़ी धीमी निष्पादन बनाता है

गैर-परमाणु:

परमाणु के विपरीत, यह सुनिश्चित नहीं करता है पूरी तरह से initialised वस्तु हर बार लौट आते हैं।

लाभ: अत्यंत तेजी से निष्पादन।

विपक्ष: बहु सूत्रण के मामले में कचरा मूल्य की संभावना है।

परमाणु केवल एक धागा चर (स्थिर प्रकार) तक पहुँचता है। परमाणु धागा सुरक्षित है, लेकिन यह धीमी है।

Nonatomic से अधिक थ्रेड चर (गतिशील प्रकार) का उपयोग होता है। Nonatomic धागे की असुरक्षित है, लेकिन यह तेजी से है।

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

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

परमाणु - यह टूट नहीं किया जा सकता है, तो परिणाम की उम्मीद है। nonatomic के साथ - जब एक और धागा एक्सेस मेमोरी क्षेत्र यह है, तो परिणाम अप्रत्याशित है संशोधित कर सकते हैं।

कोड टॉक:

परमाणु गेटर और सुरक्षित संपत्ति धागे की सेटर हैं। उदाहरण के लिए अगर यू लिखा है:

self.myProperty = value;

सुरक्षित थ्रेड है।

[myArray addObject:@"Abc"] 

सुरक्षित सूत्र नहीं है।

ऐसा कोई कीवर्ड "परमाणु"

@property(atomic, retain) UITextField *userName;

हम की तरह ऊपर का उपयोग कर सकते

@property(retain) UITextField *userName;

स्टैक ओवरफ़्लो प्रश्न देखें मैं मुद्दों हो रही है अगर मैं का उपयोग @property (परमाणु, को बनाए रखने) NSString * myString ।

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

एक इवर _internal के साथ एक संपत्ति के एमआरसी के साथ उदाहरण:

[_internal lock]; //lock
id result = [[value retain] autorelease];
[_internal unlock];
return result;

तो इन पिछले दो एक ही कर रहे हैं:

@property(atomic, retain) UITextField *userName;

@property(retain) UITextField *userName; // defaults to atomic

दूसरी ओर करता है nonatomicकि आपके कोड में कुछ भी नहीं जोड़ें। तो यह केवल सुरक्षित थ्रेड है यदि आप सुरक्षा तंत्र अपने आप को कोड।

@property(nonatomic, retain) UITextField *userName;

कीवर्ड बिल्कुल पहले संपत्ति विशेषता के रूप में लिखे जाने की जरूरत नहीं है।

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

परमाणु (डिफ़ॉल्ट)

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

nonatomic

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

अधिक देखें: https://realm.io/news/tmi-objective-c-property-attributes/

• -Atomic केवल एक ही धागे का उपयोग चर (स्थिर प्रकार) का मतलब है।
• -Atomic धागा सुरक्षित है।
• -लेकिन यह प्रदर्शन में धीमी है

कैसे घोषित करने के लिए:

परमाणु तो डिफ़ॉल्ट है के रूप में,

@property (retain) NSString *name;

और कार्यान्वयन फ़ाइल में

self.name = @"sourov";

तीन से संबंधित किसी कार्य मान लीजिए हैं

 @property (retain) NSString *name;
 @property (retain) NSString *A;
 @property (retain) NSString *B;
 self.name = @"sourov";

सभी गुण समांतर (जैसे अतुल्यकालिक रूप से) काम करते हैं।

आप धागे से "नाम" को कॉल करते हैं एक ,

तथा

एक ही समय अगर आप फोन पर

[self setName:@"Datta"]

धागे से बी ,

अब तो * नाम संपत्ति nonatomic है तो

• यह मूल्य "दत्ता" वापस आ जाएगी एक के लिए
• यह मूल्य "दत्ता" वापस आ जाएगी बी के लिए

यही कारण है कि गैर परमाणु असुरक्षित धागा कहा जाता है लेकिन लेकिन यह समानांतर निष्पादन की वजह से प्रदर्शन में तेजी से होता है

अब तो * नाम संपत्ति परमाणु है

• यह सुनिश्चित करेगा मूल्य एक के लिए "Sourov"
• तो फिर यह वापस आ जाएगी मूल्य "दत्ता 'बी के लिए

यही कारण है कि परमाणु धागा सुरक्षित कहा जाता है और यही कारण है कि यह कहा जाता है सुरक्षित पढ़ने-लिखने की है

इस तरह की स्थिति आपरेशन क्रमानुसार प्रदर्शन करेंगे। और प्रदर्शन में धीरे

- nonatomic कई धागा पहुँच चर (गतिशील प्रकार) का मतलब है।

- nonatomic असुरक्षित थ्रेड है।

- लेकिन यह प्रदर्शन में तेजी से होता है

-Nonatomic व्यवहार डिफ़ॉल्ट नहीं है, हम संपत्ति विशेषता में nonatomic कीवर्ड जोड़ने के लिए की जरूरत है।

में के लिए स्विफ्ट की पुष्टि है कि स्विफ्ट गुण ObjC अर्थ में nonatomic हैं। एक कारण यह है तो आप के बारे में है कि क्या प्रति-संपत्ति atomicity अपनी आवश्यकताओं के लिए पर्याप्त है लगता है।

संदर्भ: https://forums.developer.apple.com/thread/25642

इधर-उधर अधिक जानकारी के लिए कृपया वेबसाइट पर जाएँ http://rdcworld-iphone.blogspot.in/2012/12/variable-property-attributes-or.html

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

विजयेंद्र त्रिपाठी पहले से ही एक बहु लड़ी पर्यावरण के लिए एक उदाहरण दिया है।

आरंभ करने से पहले: आपको पता होना चाहिए कि स्मृति में हर वस्तु स्मृति से पुनः आवंटित की जाती किया जा करने के लिए एक नया लिखने होने के लिए की जरूरत है। आप न सिर्फ बस कुछ के शीर्ष पर लिखने के रूप में आप कागज पर कर सकते हैं। आप चाहिए पहले मिटा (dealloc) यह और फिर आप इसे पर लिख सकते हैं। इस समय है कि मिटा किया जाता है तो (या आधा किया) और कुछ भी नहीं अभी तक है लिखा गया है (या आधा लिखा था) और आप पढ़ने की कोशिश यह कई समस्याएं खड़ी कर सकता है! परमाणु और nonatomic मदद आप अलग अलग तरीकों से इस समस्या का इलाज।

सबसे पहले पढ़ा इस सवाल और फिर पढ़ा Bbum का जवाब । इसके अलावा उसके बाद मेरे सारांश पढ़ें।

atomic हमेशा की गारंटी देगा

• दो अलग-अलग लोगों को पढ़ने के लिए और एक ही समय में लिखना चाहते हैं, तो अपने कागज बस जला नहीं होगा! -> आपका आवेदन दुर्घटना कभी नहीं होगा, यहां तक ​​कि एक दौड़ हालत में।
• यदि एक व्यक्ति लिखने की कोशिश कर रहा है और केवल लिखित 8 अक्षरों के 4 लिखा गया है, तो कोई बीच में पढ़ सकते हैं, पढ़ने केवल जब सभी 8 पत्र लिखा है किया जा सकता है -> नहीं पढ़ा (मिल) पर क्या होगा 'एक धागा है कि अभी भी लिख रहा है', यानी अगर वहाँ बाइट्स के लिए 8 बाइट्स लिखा होना चाहिए, और केवल 4 बाइट लिखा जाता है - उस पल के लिए ऊपर, आप इसे से पढ़ने के लिए अनुमति नहीं है। लेकिन बाद से मैं ने कहा कि यह तो क्रैश नहीं करेंगे यह एक के मान से पढ़ें autoreleased वस्तु।
• तो इससे पहले कि आप लिख कर दिया है जो पहले कागज पर लिखा था कि मिट और फिर किसी आप को पढ़ने के लिए चाहता है सकते हैं अभी भी पढ़ सकते हैं। कैसे? आपके पास Mac OS ट्रैश बिन में कुछ इसी तरह से पढ़ने की जाएगी (के रूप में कचरे के डिब्बे में नहीं अभी भी 100% मिट है ... यह एक अधर में लटकी है) ---> ThreadA ThreadB पहले से ही लिखने के लिए dealloced गया है, जबकि पढ़ने के लिए है, तो आप सकता है या तो ThreadB द्वारा अंतिम पूरी तरह से लिखा मूल्य से मूल्य मिलता है या autorelease पूल से कुछ मिलता है।

को बनाये रखें मायने रखता है जिस तरह स्मृति ऑब्जेक्टिव-सी में किया जाता है कर रहे हैं। जब आप एक वस्तु बनाने के लिए, यह एक 1. की गिनती को बनाए रखने जब आप एक वस्तु संदेश को बनाए रखने के भेजने के लिए, अपने को बनाए रखने गिनती 1. द्वारा वृद्धि की जाती है जब आप एक वस्तु एक रिलीज संदेश भेजने है, इसकी बनाए रखने गिनती 1. जब आप द्वारा कम कर रहा है एक वस्तु एक भेज autorelease संदेश , अपने को बनाए रखने गिनती भविष्य में किसी चरण में 1 से कम कर रहा है। एक object's बनाए रखने गिनती 0 तक कम हो जाता है, यह पुनः आवंटित की जाती है।

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

रुको क्या?! Multithreading और कर रहे हैं धागा सुरक्षा प्रकार भिन्न है?

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

nonatomic

• के बाद से मैक ओएस ट्रैश बिन तरह ऐसी कोई बात नहीं है, तो किसी को परवाह नहीं है या नहीं, तो आप हमेशा एक मूल्य मिल (<- यह संभवतः एक दुर्घटना का कारण बन सकता), और न ही किसी को पढ़ने का प्रयास करता है, तो किसी को भी परवाह नहीं है आधे रास्ते के माध्यम से आप लिख (हालांकि आधे रास्ते स्मृति में लिखने यह आप से पहले से एक पागल बेवकूफ मूल्य है, जबकि कागज पर आप केवल क्या लिखा गया है की आधी देखने दे सकता है) स्मृति पर, आधे रास्ते कागज पर लिखने से बहुत अलग है ->, क्रैश नहीं करने की गारंटी नहीं है क्योंकि यह autorelease तंत्र का उपयोग नहीं करता।
• पूर्ण लिखा मूल्यों की गारंटी नहीं है पढ़ने के लिए!
• परमाणु की तुलना में तेजी है

कुल मिलाकर वे 2 पहलुओं में अलग हैं:

• दुर्घटनाग्रस्त या होने या autorelease पूल नहीं होने की वजह से नहीं।

• की अनुमति दे सही एक 'अभी तक नहीं समाप्त हो गया लिखने या रिक्त मान' या नहीं की इजाजत दी और केवल जब मूल्य है पढ़ने के लिए अनुमति देता है के बीच में पढ़ने के लिए पूरी तरह से लिखा है।

@property की विशेषताओं के बारे में चर्चा करने से पहले, आपको पता होना चाहिए @property का प्रयोग होता है क्या। @property जानकारी है कि एक वर्ग संपुटित करने का इरादा है परिभाषित करने के लिए एक तरह से प्रदान करता है। आप @property का उपयोग कर एक वस्तु / चर घोषित है, तो उस वस्तु / चर अपने वर्ग का आयात अन्य वर्गों के लिए सुलभ हो जाएगा। आप हेडर फाइल में @property का उपयोग कर एक वस्तु की घोषणा है, तो आप कार्यान्वयन फ़ाइल में @synthesize का उपयोग कर इसे संश्लेषण करने की है।

उदाहरण:

ज वर्ग

@interface ExampleClass : NSObject
   @property (nonatomic, retain) NSString *name;
@end

मीटर वर्ग

@implementation ExampleClass
   @synthesize name;
@end

अब संकलक नाम के लिए तरीके एक्सेसर संश्लेषण जाएगा।

ExampleClass *newObject=[[ExampleClass alloc]init];
NSString *name1=[newObject name]; // get 'name'
[obj setName:@“Tiger”];

@property की विशेषताओं की सूची: परमाणु। nonatomic। बरकरार रहती है। प्रति। सिफ़ पढ़िये। पढ़ना लिखना। आवंटित। बलवान।

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

उदाहरण :

@property NSString *name; //by default atomic
@property (atomic)NSString *name; // explicitly declared atomic

nonatomic: यह धागा सुरक्षित नहीं है। आप तो क्या होता है कि एक ही मूल्य अलग धागे से एक साथ पहुँचा जा सकता है के बारे में कोई गारंटी के साथ कि संश्लेषित accessors बस सेट तैयार करें या एक मूल्य के सीधे वापस जाने के लिए, nonatomic संपत्ति विशेषता का उपयोग कर सकते हैं। इस कारण से, यह एक परमाणु की तुलना में एक nonatomic संपत्ति का उपयोग करने के लिए तेजी से है। @property (nonatomic)NSString *name;

बनाए रखें: जब विशेषता एक object.The सेटर विधि के लिए एक सूचक, वस्तु की गिनती को बनाए रखने में वृद्धि होगी, ताकि यह autorelease पूल में स्मृति को घेरता है है की आवश्यकता है। @property (retain)NSString *name;

प्रतिलिपि: यदि आप प्रतिलिपि का उपयोग करते हैं, तो आप को बनाए रखने का उपयोग नहीं कर सकते हैं। वर्ग के प्रति उदाहरण का उपयोग करते हुए अपनी ही प्रतिलिपि होगी। यहां तक ​​कि अगर एक परिवर्तनशील स्ट्रिंग सेट और बाद में बदल दिया गया है, उदाहरण के कब्जा जो भी मान यह समय के सेट होने पर पर है। कोई सेटर और गेटर तरीकों संश्लेषित कर दिया जाएगा।

@property (copy) NSString *name;

NSMutableString *nameString = [NSMutableString stringWithString:@"Liza"];    
xyzObj.name = nameString;    
[nameString appendString:@"Pizza"];

केवल पढ़ने के लिए: यदि आप संपत्ति सेटर विधि के माध्यम से परिवर्तित करने की अनुमति देने के लिए नहीं करना चाहते हैं, तो आप संपत्ति केवल पढ़ने के लिए घोषणा कर सकते हैं। @property (readonly) NSString *name;

ReadWrite: डिफ़ॉल्ट व्यवहार है। आप स्पष्ट रूप से ReadWrite विशेषता निर्दिष्ट करने की आवश्यकता नहीं है।

@property (readwrite) NSString *name;

आवंटित: एक सेटर जो सीधे उदाहरण चर के लिए मूल्य प्रदान करती है, बल्कि कॉपी करने या इसे बनाए रखने की तुलना में उत्पन्न होगा। इस तरह के प्रतिनिधियों के रूप में आप सीधे के स्वामी नहीं हैं NSInteger और CGFloat, या वस्तुओं की तरह आदिम प्रकार, के लिए सबसे अच्छा है।

@property (assign) NSInteger year;

मजबूत: बनाए रखने के लिए एक स्थानापन्न है। @property (nonatomic, strong) AVPlayer *player;

unsafe_unretained: वहाँ कोको और कोको टच में कुछ वर्गों है कि अभी तक कमजोर संदर्भ का समर्थन नहीं करते, जिसका अर्थ है आप एक कमजोर संपत्ति या कमजोर स्थानीय चर की घोषणा नहीं कर सकते हैं उन पर नज़र रखने के लिए कर रहे हैं। इन कक्षाओं NSTextView, NSFont और NSColorSpace, आदि शामिल हैं। आप इन वर्गों में से एक के लिए एक कमजोर संदर्भ का उपयोग करने की जरूरत है, तो आप एक असुरक्षित संदर्भ का उपयोग करना चाहिए। एक असुरक्षित संदर्भ में है कि वह अपने संबंधित वस्तु जिंदा नहीं रख करता है एक कमजोर संदर्भ के समान है, लेकिन यह करता है, तो गंतव्य वस्तु पुनः आवंटित की जाती है शून्य करने के लिए सेट नहीं किया जाएगा।

@property (unsafe_unretained) NSObject *unsafeProperty;

परमाणु संपत्ति कितने धागे उस पर गेटर और सेटर कर रहे हैं की परवाह किए बिना एक पूरी तरह से initialised मूल्य बनाए रखने के लिए सुनिश्चित करता है।

nonatomic संपत्ति है कि संश्लेषित accessors बस सेट या एक मूल्य के सीधे लौटने के लिए, तो क्या होता है कि एक ही मूल्य अलग धागे से एक साथ पहुँचा जा सकता है के बारे में कोई गारंटी के साथ निर्दिष्ट करता है।

परमाणु केवल एक धागा एक समय (स्थिर प्रकार) पर चर का उपयोग कर सकते है। परमाणु धागा सुरक्षित है, लेकिन यह धीमी है।

Nonatomic से अधिक थ्रेड एक ही समय (गतिशील प्रकार) पर चर का उपयोग कर सकते है। Nonatomic धागे की असुरक्षित है, लेकिन यह तेजी से है।

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

Atomicity परमाणु (डिफ़ॉल्ट)

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

nonatomic

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

शिष्टाचार https://academy.realm.io/posts/tmi-objective-c-property-attributes/

Atomicity संपत्ति विशेषताएं (परमाणु और nonatomic) इसी स्विफ्ट संपत्ति घोषणा में परिलक्षित नहीं कर रहे हैं, लेकिन ऑब्जेक्टिव-सी कार्यान्वयन के atomicity की गारंटी देता है अभी भी पकड़ जब आयातित संपत्ति स्विफ्ट से पहुँचा है।

तो - अगर आप ऑब्जेक्टिव-सी में एक परमाणु संपत्ति को परिभाषित यह जब स्विफ्ट द्वारा इस्तेमाल किया परमाणु रहेगा।

शिष्टाचार https://medium.com/@YogevSitton/atomic-vs-non-atomic-properties-crash-course-d11c23f4366c

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

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

सच्चाई यह है कि वे परमाणु संपत्ति को लागू करने के स्पिन लॉक का उपयोग है। के रूप में नीचे दिए गए कोड:

 static inline void reallySetProperty(id self, SEL _cmd, id newValue, 
      ptrdiff_t offset, bool atomic, bool copy, bool mutableCopy) 
    {
        id oldValue;
        id *slot = (id*) ((char*)self + offset);

        if (copy) {
            newValue = [newValue copyWithZone:NULL];
        } else if (mutableCopy) {
            newValue = [newValue mutableCopyWithZone:NULL];
        } else {
            if (*slot == newValue) return;
            newValue = objc_retain(newValue);
        }

        if (!atomic) {
            oldValue = *slot;
            *slot = newValue;
        } else {
            spin_lock_t *slotlock = &PropertyLocks[GOODHASH(slot)];
            _spin_lock(slotlock);
            oldValue = *slot;
            *slot = newValue;        
            _spin_unlock(slotlock);
        }

        objc_release(oldValue);
    }

पूरे भ्रम आसान बनाने के लिए हमें म्युटेक्स lock.Mutex ताला नाम के अनुसार object.So की अस्थिरता ताले अगर वस्तु एक वर्ग द्वारा पहुँचा है समझते हैं कोई अन्य वर्ग भी एक ही object.In आईओएस @sychronise उपयोग कर सकते हैं म्युटेक्स प्रदान lock.Now यह फीफो मोड में सेवा करते हैं और यह सुनिश्चित करता प्रवाह एक ही instance.However साझा करने दो वर्गों से प्रभावित नहीं है, तो कार्य परमाणु गुण का उपयोग कर के रूप में यह अपने यूआई पकड़ और प्रदर्शन में कमी आ सकती मुख्य थ्रेड से बचने तक पहुँचने वस्तु पर है

परमाणु: धागा NSLOCK का उपयोग कर लॉक करके सुनिश्चित करें धागे की सुरक्षा।

गैर परमाणु: धागे की सुरक्षा सुनिश्चित नहीं करता है के रूप में वहाँ कोई धागा ताला लगा तंत्र है।