दिलचस्प पोस्ट
NSBlockOperation को कैसे रद्द करें एक UIScrollView के अंदर एक UITableView स्क्रोलिंग जावास्क्रिप्ट केस असंवेदनशील स्ट्रिंग तुलना PHP के प्रपत्र मान सरणी / एसोसिएटिव सरणी के Django समतुल्य कोणीय 2 में आप सक्रिय मार्ग कैसे निर्धारित करते हैं? PHP में $ _POST चर क्यों बच रहे हैं? लिट बनाम एलईटी * में आम लिस्प में data.table में शामिल होने के बाद फिर से प्रतिलिपि बिना मौजूदा डेटा.फ्रेम में कॉलम जोड़ें ASP.NET पहचान – प्रति प्रकार एकाधिक ऑब्जेक्ट सेट समर्थित नहीं हैं I स्विफ्ट में कैसे सेटअप पुश नोटिफिकेशन सी ++ में उचित ढेर और ढेर का उपयोग? RStudio में आर के स्थान को कैसे बदल सकता है? Android में गतिशील रूप से एक LinearLayout पर मैं एक TextView कैसे जोड़ सकता / सकती हूं? स्पार्क एएलएस भविष्यवाणी सभी खाली रिटर्न कैसे जावास्क्रिप्ट में एक फ़ाइल ऑब्जेक्ट को इन्स्तांत?

मेरा उद्देश्य-सी सिंगलटन कैसा दिखता है?

मेरी सिंगलटन एक्सेसर विधि आमतौर पर निम्न प्रकार है:

static MyClass *gInstance = NULL; + (MyClass *)instance { @synchronized(self) { if (gInstance == NULL) gInstance = [[self alloc] init]; } return(gInstance); } 

मैं इसे सुधारने के लिए क्या कर सकता हूं?

Solutions Collecting From Web of "मेरा उद्देश्य-सी सिंगलटन कैसा दिखता है?"

एक अन्य विकल्प +(void)initialize विधि का उपयोग करना है। प्रलेखन से:

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

तो आप ऐसा कुछ कर सकते हैं:

 static MySingleton *sharedSingleton; + (void)initialize { static BOOL initialized = NO; if(!initialized) { initialized = YES; sharedSingleton = [[MySingleton alloc] init]; } } 
 @interface MySingleton : NSObject { } + (MySingleton *)sharedSingleton; @end @implementation MySingleton + (MySingleton *)sharedSingleton { static MySingleton *sharedSingleton; @synchronized(self) { if (!sharedSingleton) sharedSingleton = [[MySingleton alloc] init]; return sharedSingleton; } } @end 

[स्रोत]

मेरे अन्य उत्तर के नीचे, मुझे लगता है कि आपको करना चाहिए:

 + (id)sharedFoo { static dispatch_once_t once; static MyFoo *sharedFoo; dispatch_once(&once, ^ { sharedFoo = [[self alloc] init]; }); return sharedFoo; } 

चूंकि केंडल ने एक थ्रेसेफ सिंगलटन पोस्ट किया जो लॉकिंग लागत से बचने का प्रयास करता है, मैंने सोचा कि मैं भी एक ऊपर टॉस करूँगा:

 #import <libkern/OSAtomic.h> static void * volatile sharedInstance = nil; + (className *) sharedInstance { while (!sharedInstance) { className *temp = [[self alloc] init]; if(!OSAtomicCompareAndSwapPtrBarrier(0x0, temp, &sharedInstance)) { [temp release]; } } return sharedInstance; } 

ठीक है, मुझे बताएं कि यह कैसे काम करता है:

  1. फास्ट केस: सामान्य निष्पादन में sharedInstance की गई व्यवस्था पहले से ही निर्धारित की गई है, इसलिए while लूप निष्पादित नहीं होता है और केवल चर के अस्तित्व का परीक्षण करने के बाद फ़ंक्शन देता है;

  2. धीमा मामला: अगर sharedInstance अस्तित्व में नहीं है, तो एक तुलना आवंटित और स्वैप ('सीएएस') का उपयोग करके एक आवंटन आवंटित किया गया है;

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

 स्थिर MyClass * sharedInst = शून्य;

 + (आईडी) साझा अंतर
 {
     @ सिंक्रनाइज़ (स्वयं) {
         अगर (shareInst == शून्य) {
             / * init में स्थापित shareInst * /
             [[स्वयं आलोक] इनिट];
         }
     }
     रिटर्न shareInst;
 }

 - (आईडी) init
 {
     अगर (shareInst! = शून्य) {
         [एनएसई एक्सपैशन बढ़ाएं: एनएसआईआईएनआईआईएनआईएन्सिन्सिस्टेंसी एक्सपेशेशन
             प्रारूप: @ "[% @% @] को नहीं कहा जा सकता है, इसके बजाय + [% @% @] का प्रयोग करें]],
             NSStringFromClass ([आत्म वर्ग]), NSStringFromSelector (_cmd), 
             NSStringFromClass ([आत्म वर्ग]),
             NSStringFromSelector (@selector (sharedInstance) "];
     } और अगर (आत्म = [सुपर इनिट]) {
         sharedInst = self;
         / * यहां जो भी वर्ग विशिष्ट है / /
     }
     रिटर्न shareInst;
 }

 / * ये शायद कुछ भी नहीं करते हैं
    एक जीसी ऐप  सिंगलटन को रखता है
    एक में एक वास्तविक सिंगलटन के रूप में
    गैर सीजी एप्लिकेशन
 * /
 - (एनएसयूइंटर) को बनाए रखने की संख्या
 {
     वापसी NSUIntegerMax;
 }

 - (ऑनवे रिक्त) रिहाई
 {
 }

 - (आईडी) को बनाए रखने
 {
     रिटर्न shareInst;
 }

 - (आईडी) ऑटोरेक्लेज़
 {
     रिटर्न shareInst;
 }

संपादित करें: एआरसी से यह क्रियान्वयन अप्रचलित है एआरसी के साथ संगत एक उद्देश्य सी सिंगलटन को मैं कैसे लागू करूँ? सही कार्यान्वयन के लिए

मैंने अन्य उत्तरों में पढ़ा है I प्रारंभ में एक सामान्य त्रुटि साझा करने के सभी कार्यान्वयन।

 + (void) initialize { _instance = [[MySingletonClass alloc] init] // <----- Wrong! } + (void) initialize { if (self == [MySingletonClass class]){ // <----- Correct! _instance = [[MySingletonClass alloc] init] } } 

ऐप्पल प्रलेखन आपको अपने आरंभिक ब्लॉक में क्लास प्रकार की जांच करने की सलाह देते हैं। चूंकि उपवर्ग प्राथमिक रूप से प्रारंभिक रूप से कॉल करते हैं एक गैर-स्पष्ट मामला मौजूद है जहां उप-वर्ग केवीओ के द्वारा अप्रत्यक्ष रूप से बनाया जा सकता है। यदि आप किसी अन्य श्रेणी में निम्नलिखित पंक्ति जोड़ते हैं:

 [[MySingletonClass getInstance] addObserver:self forKeyPath:@"foo" options:0 context:nil] 

उद्देश्य-सी माइस्सिंगटन क्लास का एक उप-वर्ग तैयार करेगा, जिसके परिणामस्वरूप एक दूसरे के ट्रिगरिंग में +initialize

आप सोच सकते हैं कि आपको अपने इनिट ब्लॉक में डुप्लिकेट आरंभीकरण की जांच करना चाहिए जैसे कि:

 - (id) init { <----- Wrong! if (_instance != nil) { // Some hack } else { // Do stuff } return self; } 

लेकिन आप अपने आप को पैर में गोली मार देंगे; या बदतर एक और डेवलपर के लिए खुद को पैर में गोली मार का अवसर दे।

 - (id) init { <----- Correct! NSAssert(_instance == nil, @"Duplication initialization of singleton"); self = [super init]; if (self){ // Do stuff } return self; } 

टीएल; डीआर, यहां मेरा कार्यान्वयन है

 @implementation MySingletonClass static MySingletonClass * _instance; + (void) initialize { if (self == [MySingletonClass class]){ _instance = [[MySingletonClass alloc] init]; } } - (id) init { ZAssert (_instance == nil, @"Duplication initialization of singleton"); self = [super init]; if (self) { // Initialization } return self; } + (id) getInstance { return _instance; } @end 

(हमारे स्वयं का दावा मैक्रो के साथ ZAssert बदलें या सिर्फ NSAssert।)

सिंगलटन मैक्रो कोड का संपूर्ण विवरण ब्लॉग कोको इन लव से ब्लॉग पर है

http://cocoawithlove.com/2008/11/singletons-appdelegates-and-top-level.html

मेरे साझा अनुभव पर एक दिलचस्प भिन्नता है जो धागा सुरक्षित है, लेकिन प्रारंभिकरण के बाद लॉक नहीं करता है। मैं अभी तक इसके बारे में पूछताछ के रूप में शीर्ष उत्तर को संशोधित करने के लिए पर्याप्त नहीं हूं, लेकिन मैं इसे और चर्चा के लिए प्रस्तुत करता हूं:

 // Volatile to make sure we are not foiled by CPU caches static volatile ALBackendRequestManager *sharedInstance; // There's no need to call this directly, as method swizzling in sharedInstance // means this will get called after the singleton is initialized. + (MySingleton *)simpleSharedInstance { return (MySingleton *)sharedInstance; } + (MySingleton*)sharedInstance { @synchronized(self) { if (sharedInstance == nil) { sharedInstance = [[MySingleton alloc] init]; // Replace expensive thread-safe method // with the simpler one that just returns the allocated instance. SEL origSel = @selector(sharedInstance); SEL newSel = @selector(simpleSharedInstance); Method origMethod = class_getClassMethod(self, origSel); Method newMethod = class_getClassMethod(self, newSel); method_exchangeImplementations(origMethod, newMethod); } } return (MySingleton *)sharedInstance; } 

संक्षिप्त जवाब: शानदार।

लंबा जवाब: कुछ ऐसा ….

 static SomeSingleton *instance = NULL; @implementation SomeSingleton + (id) instance { static dispatch_once_t onceToken; dispatch_once(&onceToken, ^{ if (instance == NULL){ instance = [[super allocWithZone:NULL] init]; } }); return instance; } + (id) allocWithZone:(NSZone *)paramZone { return [[self instance] retain]; } - (id) copyWithZone:(NSZone *)paramZone { return self; } - (id) autorelease { return self; } - (NSUInteger) retainCount { return NSUIntegerMax; } - (id) retain { return self; } @end 

क्या हो रहा है यह समझने के लिए प्रेषण / एकबार हेडर को पढ़ना सुनिश्चित करें। इस मामले में हेडर टिप्पणियां डॉक्स या मैन पेज से अधिक लागू होती हैं।

मैंने सिंगलटन को एक कक्षा में रोल किया है, इसलिए अन्य कक्षाएं सिंगलटन गुणों को प्राप्त कर सकती हैं।

सिंगलटन एच:

 static id sharedInstance = nil; #define DEFINE_SHARED_INSTANCE + (id) sharedInstance { return [self sharedInstance:&sharedInstance]; } \ + (id) allocWithZone:(NSZone *)zone { return [self allocWithZone:zone forInstance:&sharedInstance]; } @interface Singleton : NSObject { } + (id) sharedInstance; + (id) sharedInstance:(id*)inst; + (id) allocWithZone:(NSZone *)zone forInstance:(id*)inst; @end 

सिंगलटन.एम:

 #import "Singleton.h" @implementation Singleton + (id) sharedInstance { return [self sharedInstance:&sharedInstance]; } + (id) sharedInstance:(id*)inst { @synchronized(self) { if (*inst == nil) *inst = [[self alloc] init]; } return *inst; } + (id) allocWithZone:(NSZone *)zone forInstance:(id*)inst { @synchronized(self) { if (*inst == nil) { *inst = [super allocWithZone:zone]; return *inst; // assignment and return on first allocation } } return nil; // on subsequent allocation attempts return nil } - (id)copyWithZone:(NSZone *)zone { return self; } - (id)retain { return self; } - (unsigned)retainCount { return UINT_MAX; // denotes an object that cannot be released } - (void)release { //do nothing } - (id)autorelease { return self; } @end 

और यहाँ कुछ वर्ग का एक उदाहरण है, आप सिंगलटन बनना चाहते हैं।

 #import "Singleton.h" @interface SomeClass : Singleton { } @end @implementation SomeClass DEFINE_SHARED_INSTANCE; @end 

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

यह गैर-कचरा एकत्रित वातावरण में भी काम करता है।

 @interface MySingleton : NSObject { } +(MySingleton *)sharedManager; @end @implementation MySingleton static MySingleton *sharedMySingleton = nil; +(MySingleton*)sharedManager { @synchronized(self) { if (sharedMySingleton == nil) { [[self alloc] init]; // assignment not done here } } return sharedMySingleton; } +(id)allocWithZone:(NSZone *)zone { @synchronized(self) { if (sharedMySingleton == nil) { sharedMySingleton = [super allocWithZone:zone]; return sharedMySingleton; // assignment and return on first allocation } } return nil; //on subsequent allocation attempts return nil } -(void)dealloc { [super dealloc]; } -(id)copyWithZone:(NSZone *)zone { return self; } -(id)retain { return self; } -(unsigned)retainCount { return UINT_MAX; //denotes an object that cannot be release } -(void)release { //do nothing } -(id)autorelease { return self; } -(id)init { self = [super init]; sharedMySingleton = self; //initialize here return self; } @end 

क्या यह थरसेफ नहीं होगा और पहले कॉल के बाद महंगा लॉकिंग से बचें?

 + (MySingleton*)sharedInstance { if (sharedInstance == nil) { @synchronized(self) { if (sharedInstance == nil) { sharedInstance = [[MySingleton alloc] init]; } } } return (MySingleton *)sharedInstance; } 

यहाँ एक मैक्रो है जिसे मैंने एक साथ रखा है:

http://github.com/cjhanson/Objective-C-Optimized-Singleton

यह मैट गैलाघर द्वारा यहां काम पर आधारित है लेकिन Google के डेव मैकलेचलन द्वारा वर्णित विधि स्विसिंग का उपयोग करने के लिए कार्यान्वयन को बदलना

मैं टिप्पणी / योगदान का स्वागत करता हूं

कैसा रहेगा

 static MyClass *gInstance = NULL; + (MyClass *)instance { if (gInstance == NULL) { @synchronized(self) { if (gInstance == NULL) gInstance = [[self alloc] init]; } } return(gInstance); } 

तो आप आरंभ करने के बाद सिंक्रनाइज़ेशन लागत से बचें?

उद्देश्य-सी में सिंगलटन पैटर्न की गहन चर्चा के लिए, यहां पर देखें:

उद्देश्य-सी में सिंगलटन पैटर्न का उपयोग करना

KLSingleton है:

  1. उप-वर्ग (एन-वें डिग्री)
  2. एआरसी संगत
  3. alloc और init साथ सुरक्षित
  4. भरा हुआ आलोक
  5. सुरक्षित धागा
  6. लॉक-फ्री (उपयोग + प्रारंभ, सिंक्रनाइज़ @ नहीं)
  7. मैक्रो-मुक्त
  8. धूर्तता से मुक्त
  9. सरल

KLSingleton

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

 @implementation MYSingleton static MYSingleton * sharedInstance = nil; +( id )sharedInstance { @synchronized( [ MYSingleton class ] ) { if( sharedInstance == nil ) sharedInstance = [ [ MYSingleton alloc ] init ]; } return sharedInstance; } +( id )allocWithZone:( NSZone * )zone { @synchronized( [ MYSingleton class ] ) { if( sharedInstance == nil ) sharedInstance = [ super allocWithZone:zone ]; } return sharedInstance; } -( id )init { @synchronized( [ MYSingleton class ] ) { self = [ super init ]; if( self != nil ) { // Insert initialization code here } return self; } } @end 

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

 static Server *instance; + (Server *)instance { return instance; } + (id)hiddenAlloc { return [super alloc]; } + (id)alloc { return [[self instance] retain]; } + (void)initialize { static BOOL initialized = NO; if(!initialized) { initialized = YES; instance = [[Server hiddenAlloc] init]; } } - (id) init { if (instance) return self; self = [super init]; if (self != nil) { // whatever } return self; } 
 static mySingleton *obj=nil; @implementation mySingleton -(id) init { if(obj != nil){ [self release]; return obj; } else if(self = [super init]) { obj = self; } return obj; } +(mySingleton*) getSharedInstance { @synchronized(self){ if(obj == nil) { obj = [[mySingleton alloc] init]; } } return obj; } - (id)retain { return self; } - (id)copy { return self; } - (unsigned)retainCount { return UINT_MAX; // denotes an object that cannot be released } - (void)release { if(obj != self){ [super release]; } //do nothing } - (id)autorelease { return self; } -(void) dealloc { [super dealloc]; } @end 

मुझे पता है कि इस "प्रश्न" पर बहुत सारी टिप्पणियां हैं, लेकिन मुझे सिंगलटन को परिभाषित करने के लिए मैक्रो का उपयोग करने के कई लोगों का सुझाव नहीं मिलता है यह एक समान पैटर्न है और मैक्रो काफी सिंगलटन को सरल करता है

मैंने देखा है कि कई ओब्जेक लागूकरण के आधार पर यहां लिखा मैक्रोज़ हैं I

Singeton.h

 /** @abstract Helps define the interface of a singleton. @param TYPE The type of this singleton. @param NAME The name of the singleton accessor. Must match the name used in the implementation. @discussion Typcially the NAME is something like 'sharedThing' where 'Thing' is the prefix-removed type name of the class. */ #define SingletonInterface(TYPE, NAME) \ + (TYPE *)NAME; /** @abstract Helps define the implementation of a singleton. @param TYPE The type of this singleton. @param NAME The name of the singleton accessor. Must match the name used in the interface. @discussion Typcially the NAME is something like 'sharedThing' where 'Thing' is the prefix-removed type name of the class. */ #define SingletonImplementation(TYPE, NAME) \ static TYPE *__ ## NAME; \ \ \ + (void)initialize \ { \ static BOOL initialized = NO; \ if(!initialized) \ { \ initialized = YES; \ __ ## NAME = [[TYPE alloc] init]; \ } \ } \ \ \ + (TYPE *)NAME \ { \ return __ ## NAME; \ } 

उपयोग के उदाहरण:

MyManager.h

 @interface MyManager SingletonInterface(MyManager, sharedManager); // ... @end 

MyManager.m

 @implementation MyManager - (id)init { self = [super init]; if (self) { // Initialization code here. } return self; } SingletonImplementation(MyManager, sharedManager); // ... @end 

क्यों एक अंतरफलक मैक्रो जब यह लगभग खाली है? हेडर और कोड फ़ाइलों के बीच संगतता कोड; रखरखाव के मामले में आप अधिक स्वचालित तरीके जोड़ना चाहते हैं या इसे चारों ओर बदल सकते हैं।

मैं सिंगलटन बनाने के लिए इनिशियलाइज़ विधि का उपयोग कर रहा हूं जैसा कि यहां सबसे लोकप्रिय उत्तर में (लेखन के समय) उपयोग किया जाता है।

उद्देश्य सी क्लास के तरीकों के साथ, हम केवल सिंगलटन पद्धति का उपयोग सामान्य तरीके से कर सकते हैं:

 [[Librarian sharedInstance] openLibrary] 

सेवा मेरे:

 [Librarian openLibrary] 

क्लास के अंदर वर्ग को लपेटकर क्लास मेथड्स है , इस तरह गलती से डुप्लिकेट इंस्टेंस बनाने की कोई संभावना नहीं है, क्योंकि हम कोई इवेंट नहीं बना रहे हैं!

मैंने यहां अधिक विस्तृत ब्लॉग लिखा था 🙂

@ रॉबी-हंससन से उदाहरण का विस्तार करने के लिए …

 static MySingleton* sharedSingleton = nil; + (void)initialize { static BOOL initialized = NO; if (!initialized) { initialized = YES; sharedSingleton = [[self alloc] init]; } } - (id)init { self = [super init]; if (self) { // Member initialization here. } return self; } 

मेरा रास्ता इस तरह सरल है:

 static id instanceOfXXX = nil; + (id) sharedXXX { static volatile BOOL initialized = NO; if (!initialized) { @synchronized([XXX class]) { if (!initialized) { instanceOfXXX = [[XXX alloc] init]; initialized = YES; } } } return instanceOfXXX; } 

यदि सिंगलटन पहले ही आरंभीकृत है, तो लॉक ब्लॉक दर्ज नहीं किया जाएगा। दूसरा जांच अगर (आरंभिक रूप से) यह सुनिश्चित करने के लिए है कि यह अभी तक प्रारंभ नहीं किया गया है जब वर्तमान थ्रेड ने लॉक प्राप्त किया है

मैंने सभी समाधानों के माध्यम से नहीं पढ़ा है, इसलिए यदि यह कोड बेमानी है तो माफ कर दो।

मेरी राय में यह सबसे धागा सुरक्षित कार्यान्वयन है

 +(SingletonObject *) sharedManager { static SingletonObject * sharedResourcesObj = nil; @synchronized(self) { if (!sharedResourcesObj) { sharedResourcesObj = [[SingletonObject alloc] init]; } } return sharedResourcesObj; } 

मैं आम तौर पर बेन हॉफ़स्टीन के उत्तर में उसी तरह के कोड का उपयोग करता हूं (जो भी विकिपीडिया से बाहर हो गया)। मैं क्रिस हेनसन द्वारा अपनी टिप्पणी में बताए गए कारणों के लिए इसका उपयोग करता हूं

हालांकि, कभी-कभी मुझे एक सिंगलटन को एनआईबी में रखने की ज़रूरत होती है, और उस स्थिति में मैं निम्नलिखित का उपयोग करता हूं:

 @implementation Singleton static Singleton *singleton = nil; - (id)init { static BOOL initialized = NO; if (!initialized) { self = [super init]; singleton = self; initialized = YES; } return self; } + (id)allocWithZone:(NSZone*)zone { @synchronized (self) { if (!singleton) singleton = [super allocWithZone:zone]; } return singleton; } + (Singleton*)sharedSingleton { if (!singleton) [[Singleton alloc] init]; return singleton; } @end 

I leave the implementation of -retain (etc.) to the reader, although the above code is all you need in a garbage collected environment.

The accepted answer, although it compiles, is incorrect.

 + (MySingleton*)sharedInstance { @synchronized(self) <-------- self does not exist at class scope { if (sharedInstance == nil) sharedInstance = [[MySingleton alloc] init]; } return sharedInstance; } 

Per Apple documentation:

… You can take a similar approach to synchronize the class methods of the associated class, using the Class object instead of self.

Even if using self works, it shouldn't and this looks like a copy and paste mistake to me. The correct implementation for a class factory method would be:

 + (MySingleton*)getInstance { @synchronized([MySingleton class]) { if (sharedInstance == nil) sharedInstance = [[MySingleton alloc] init]; } return sharedInstance; }