Singleton Objective-C ของฉันควรมีลักษณะอย่างไร [ปิด]

วิธีการเข้าถึงเดี่ยวของฉันมักจะแตกต่างจาก:

static MyClass *gInstance = NULL;

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

    return(gInstance);
}

ฉันจะทำอะไรเพื่อปรับปรุงสิ่งนี้

อีกทางเลือกหนึ่งคือการใช้+(void)initializeวิธีการ จากเอกสาร:

รันไทม์ส่งinitializeไปยังแต่ละคลาสในโปรแกรมหนึ่งครั้งก่อนที่คลาสหรือคลาสใดก็ตามที่สืบทอดจากคลาสนั้นจะถูกส่งข้อความแรกจากภายในโปรแกรม (ดังนั้นเมธอดอาจไม่ถูกเรียกใช้หากไม่ได้ใช้คลาส) รันไทม์ส่งinitializeข้อความไปยังคลาสในลักษณะที่ปลอดภัยต่อเธรด ซูเปอร์คลาสได้รับข้อความนี้ก่อนคลาสย่อย

ดังนั้นคุณสามารถทำสิ่งที่คล้ายกับนี้:

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;
}

เนื่องจากKendall โพสต์ซิงเกิลafeafeที่พยายามหลีกเลี่ยงการล็อคค่าใช้จ่ายฉันคิดว่าฉันจะโยนหนึ่งครั้งด้วย:

#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ไม่มีอยู่จะมีการจัดสรรและคัดลอกอินสแตนซ์โดยใช้การเปรียบเทียบและสลับ ('CAS')

3. กรณีที่มีการโต้แย้ง: หากทั้งสองเธรดพยายามโทรsharedInstanceในเวลาเดียวกันและ sharedInstanceไม่มีอยู่ในเวลาเดียวกันทั้งสองจะเริ่มต้นอินสแตนซ์ใหม่ของซิงเกิลและพยายามที่จะ CAS เข้าสู่ตำแหน่ง ใดก็ตามที่ใครชนะผลตอบแทน CAS ทันทีแล้วแต่จำนวนใดคนหนึ่งสูญเสียการเผยแพร่เช่นมันเป็นเพียงแค่การจัดสรรและผลตอบแทน sharedInstance(ตอนนี้ตั้งไว้) เดี่ยวOSAtomicCompareAndSwapPtrBarrierทำหน้าที่เป็นทั้งอุปสรรคการเขียนสำหรับเธรดการตั้งค่าและอุปสรรคการอ่านจากเธรดการทดสอบ

MyClass * แบบคงที่ sharedInst = nil;

+ (id) sharedInstance
{
    @ ซิงโครไนซ์ (ตนเอง) {
        if (sharedInst == ไม่มี) {
            / * sharedInst ตั้งค่าใน init * /
            [[จัดสรรตนเอง] init];
        }
    }
    ส่งคืน sharedInst;
}

- (id) init
{
    if (sharedInst! = nil) {
        [การเพิ่ม NSException: NSInternalInconsistencyException
            รูปแบบ: @ "[% @% @] ไม่สามารถเรียกได้ใช้ + [% @% @] แทน"],
            NSStringFromClass ([ระดับตนเอง]), NSStringFromSelector (_cmd) 
            NSStringFromClass ([ระดับตนเอง]),
            NSStringFromSelector (@selector (sharedInstance) "];
    } อื่นถ้า (self = [super init]) {
        sharedInst = ตนเอง;
        / * ชั้นเรียนเฉพาะที่นี่ * /
    }
    ส่งคืน sharedInst;
}

/ * สิ่งเหล่านี้อาจจะไม่ทำอะไรเลย
   แอพ GC ช่วยให้ซิงเกิล
   เป็นซิงเกิลจริงใน
   แอปที่ไม่ใช่ CG
* /
- (NSUInteger) keepCount
{
    ส่งคืน NSUIntegerMax;
}

- (เป็นโมฆะทางเดียว) ปล่อย
{
}

- (id) เก็บ
{
    ส่งคืน sharedInst;
}

- (id) การลบอัตโนมัติ
{
    ส่งคืน sharedInst;
}

แก้ไข: การใช้งานนี้ล้าสมัยกับ ARC โปรดดูที่ฉันจะใช้ Objective-C singleton ที่เข้ากันได้กับ ARC ได้อย่างไร สำหรับการใช้งานที่ถูกต้อง

การใช้งานทั้งหมดของการเริ่มต้นฉันได้อ่านในคำตอบอื่น ๆ แบ่งปันข้อผิดพลาดทั่วไป

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

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

เอกสารประกอบของ Apple แนะนำให้คุณตรวจสอบประเภทของชั้นเรียนในบล็อกเริ่มต้นของคุณ เพราะคลาสย่อยเรียกการเริ่มต้นตามค่าเริ่มต้น มีกรณีที่ไม่ชัดเจนซึ่งอาจสร้างคลาสย่อยทางอ้อมผ่าน KVO สำหรับถ้าคุณเพิ่มบรรทัดต่อไปนี้ในคลาสอื่น:

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

Objective-C โดยปริยายจะสร้าง subclass ของ MySingletonClass +initializeผลในสองเรียกของ

คุณอาจคิดว่าคุณควรตรวจสอบการกำหนดค่าเริ่มต้นซ้ำในบล็อก init ของคุณโดยปริยายเช่น:

- (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;
}

TL; DR นี่คือการดำเนินการของฉัน

@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)

คำอธิบายอย่างละเอียดของรหัสแมโคร Singleton อยู่ในบล็อก Cocoa With Love

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

ฉันมีรูปแบบที่น่าสนใจใน sharedInstance ซึ่งเป็นเธรดที่ปลอดภัย แต่ไม่ล็อคหลังจากการเริ่มต้น ฉันยังไม่พอที่จะแก้ไขคำตอบยอดนิยมตามที่ร้องขอ แต่ฉันนำเสนอสำหรับการอภิปรายเพิ่มเติม:

// 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

อย่าลืมอ่านส่วนหัวการส่งข้อมูล / ครั้งเดียวเพื่อทำความเข้าใจว่าเกิดอะไรขึ้น ในกรณีนี้ความคิดเห็นส่วนหัวจะสามารถใช้งานได้มากกว่าเอกสารหรือหน้าคน

ฉันกลิ้งเดี่ยวลงในชั้นเรียนเพื่อให้ชั้นเรียนอื่นสามารถสืบทอดคุณสมบัติของซิงเกิล

Singleton.h:

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

Singleton.m:

#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

ข้อ จำกัด เพียงอย่างเดียวเกี่ยวกับคลาส Singleton คือเป็นคลาสย่อย NSObject แต่เวลาส่วนใหญ่ฉันใช้ singletons ในรหัสของฉันพวกเขาเป็นจริง subclasses NSObject ดังนั้นชั้นนี้จริง ๆ ชีวิตของฉันและทำให้รหัสสะอาด

งานนี้อยู่ในสภาพแวดล้อมที่ไม่เก็บขยะด้วย

@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

มันขึ้นอยู่กับการทำงานที่นี่โดยแมตต์กัลลาเกอร์ แต่การเปลี่ยนแปลงการดำเนินการเพื่อการใช้งานวิธีการ swizzling ตามที่อธิบายไว้ที่นี่โดย Dave MacLachlan ของ Google

ฉันยินดีรับฟังความคิดเห็น / การมีส่วนร่วม

เกี่ยวกับ

static MyClass *gInstance = NULL;

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

    return(gInstance);
}

ดังนั้นคุณหลีกเลี่ยงค่าใช้จ่ายในการซิงโครไนซ์หลังจากการเริ่มต้น?

สำหรับการสนทนาเชิงลึกของรูปแบบซิงเกิลใน Objective-C ดูที่นี่:

การใช้รูปแบบซิงเกิลใน Objective-C

KLSingleton คือ:

1. Subclassible (ถึงระดับ n-th)
2. รองรับ ARC
3. ปลอดภัยด้วยallocและinit
4. เต็มไปด้วยความเกียจคร้าน
5. Thread ปลอดภัย
6. ไม่ล็อค (ใช้ + เริ่มต้นไม่ใช่ @ ซิงโครไนซ์)
7. มาโครฟรี
8. Swizzle ฟรี
9. ง่าย

KLSingleton

คุณไม่ต้องการซิงโครไนซ์กับตัวเอง ... เนื่องจากวัตถุของตัวเองยังไม่มีอยู่! คุณสิ้นสุดการล็อคค่า ID ชั่วคราว คุณต้องการตรวจสอบให้แน่ใจว่าไม่มีใครสามารถเรียกใช้วิธีการเรียน (sharedInstance, alloc, allocWithZone :, ฯลฯ ) ดังนั้นคุณต้องซิงโครไนซ์กับวัตถุคลาสแทน:

@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

แค่อยากจะออกจากที่นี่เพื่อฉันจะไม่ทำมันหาย ข้อดีของอันนี้ก็คือมันสามารถใช้งานได้ใน InterfaceBuilder ซึ่งเป็นข้อดีอย่างมาก สิ่งนี้นำมาจากคำถามอื่นที่ฉันถาม :

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

ฉันรู้ว่ามีความคิดเห็นมากมายเกี่ยวกับ "คำถาม" นี้ แต่ฉันไม่เห็นหลายคนแนะนำให้ใช้แมโครเพื่อกำหนดซิงเกิล มันเป็นรูปแบบทั่วไปและแมโครช่วยลดความซับซ้อนของซิงเกิลได้อย่างมาก

นี่คือมาโครที่ฉันเขียนโดยยึดตามการใช้งาน Objc หลายอย่างที่ฉันเคยเห็น

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

ทำไมมาโครของอินเตอร์เฟสเมื่อมันเกือบจะว่างเปล่า? ความสอดคล้องของรหัสระหว่างส่วนหัวและไฟล์รหัส การบำรุงรักษาในกรณีที่คุณต้องการเพิ่มวิธีการอัตโนมัติมากขึ้นหรือเปลี่ยนไปรอบ ๆ

ฉันใช้วิธีการเริ่มต้นเพื่อสร้างซิงเกิลตันที่ใช้ในคำตอบที่ได้รับความนิยมมากที่สุดที่นี่ (ตอนที่เขียน)

ด้วยเมธอดคลาส Objective C เราสามารถหลีกเลี่ยงการใช้รูปแบบซิงเกิลตันตามปกติจาก:

[[Librarian sharedInstance] openLibrary]

ถึง:

[Librarian openLibrary]

โดยการรวมคลาสไว้ในอีกคลาสที่มีเมธอดของคลาสวิธีนั้นจึงไม่มีโอกาสที่จะสร้างอินสแตนซ์ที่ซ้ำกันโดยบังเอิญเนื่องจากเราไม่ได้สร้างอินสแตนซ์ใด ๆ !

ฉันเขียนบล็อกที่มีรายละเอียดเพิ่มเติมที่นี่ :)

หากต้องการขยายตัวอย่างจาก @ robbie-hanson ...

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;
}

หากการเตรียมใช้งานซิงเกิลตันอยู่แล้วบล็อก LOCK จะไม่ถูกป้อน การตรวจสอบครั้งที่สองหาก (! เริ่มต้น) คือการทำให้แน่ใจว่ายังไม่ได้เริ่มต้นเมื่อเธรดปัจจุบันได้รับ LOCK

ฉันไม่ได้อ่านวิธีแก้ปัญหาทั้งหมดดังนั้นโปรดให้อภัยหากรหัสนี้ซ้ำซ้อน

นี่เป็นการปฏิบัติที่ปลอดภัยที่สุดในความคิดของฉัน

+(SingletonObject *) sharedManager
{
    static SingletonObject * sharedResourcesObj = nil;

    @synchronized(self)
    {
        if (!sharedResourcesObj)
        {
            sharedResourcesObj = [[SingletonObject alloc] init];
        }
    }

    return sharedResourcesObj;
}

ฉันมักจะใช้รหัสคล้าย ๆ กับคำตอบของเบ็นฮอฟสไตน์ (ซึ่งฉันได้ออกจากวิกิพีเดียด้วย) ฉันใช้มันด้วยเหตุผลที่ Chris Hanson ระบุไว้ในความคิดเห็นของเขา

อย่างไรก็ตามบางครั้งฉันจำเป็นต้องใส่ซิงเกิลตันลงใน NIB และในกรณีนี้ฉันใช้ดังต่อไปนี้:

@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

ฉันปล่อยให้การนำไปปฏิบัติ-retain(ฯลฯ ) ไปยังผู้อ่านถึงแม้ว่าโค้ดข้างต้นเป็นสิ่งที่คุณต้องการในสภาพแวดล้อมที่เก็บขยะ

คำตอบที่ได้รับการยอมรับแม้ว่ามันจะรวบรวมไม่ถูกต้อง

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

ตามเอกสารของ Apple:

... คุณสามารถใช้วิธีการที่คล้ายกันเพื่อซิงโครไนซ์วิธีการเรียนของคลาสที่เกี่ยวข้องโดยใช้วัตถุคลาสแทนตนเอง

แม้ว่าจะใช้การทำงานด้วยตนเองมันก็ไม่ควรและนี่ดูเหมือนจะเป็นความผิดพลาดในการคัดลอกและวางของฉัน การใช้งานที่ถูกต้องสำหรับวิธีคลาสโรงงานจะเป็น:

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