這是權威參考計算Objective C單例實現？

Question

在仔細研究單身人士文學之後，下面是我編造的。 我忘了什麼嗎？

@implementation MySingleton 

static MySingleton *mySharedInstance = nil; 

//called by atexit on exit, to ensure all resources are freed properly (not just memory) 
static void singleton_remover() 
{ 
    //free resources here 
} 

+ (MySingleton*) sharedInstance{ 
    return mySharedInstance; 
} 

+ (void)initialize { 
    if (self == [MySingleton class]) { 
     mySharedInstance = [[super allocWithZone:NULL] init]; 
    atexit(singleton_remover);  
    } 
} 

+ (id)allocWithZone:(NSZone *)zone 
{ 
    return [self sharedInstance]; 
} 

- (id)copyWithZone:(NSZone *)zone 
{ 
    return self;  
} 

- (id)retain 
{ 
    return self;  
} 

- (NSUInteger)retainCount 
{ 
    return NSUIntegerMax; //denotes an object that cannot be released 
} 

- (void)release 
{ 
    //do nothing  
} 

- (id)autorelease 
{ 
    return self;  
} 

Answer 1

避免了同步鎖最 的

如果你想你的軟件是可靠的，避免工作的構造時間「大部分時間」

http://developer.apple.com/mac/library/DOCUMENTATION/Cocoa/Conceptual/Multithreading/ThreadSafety/ThreadSafety.html

表4.1。雙重檢查鎖

雙重檢查鎖試圖通過在鎖定之前測試鎖定標準來降低獲取鎖的開銷。由於雙重檢查的鎖可能不安全，系統不提供對它們的明確支持，因此不鼓勵使用它們。

Answer 2

一些建議（更適用於Mac可可超過iPhone，但它可能是有用的，其他人搜索Objective-C的標籤）：

• 不要打擾-allocWithZone：NULL，只是平原-alloc將會很好。
• 考慮使用dispatch_once（）或調用pthread_once（），其中可
• 裏的AtExit用法是聰明，但可能無法與快速應用程序終止（不知道這是否適用於iPhone）兼容，因爲這有效殺滅-9s應用

一個額外的樂趣模式：

+ (Foo *)sharedFoo { 
    static Foo *sharedInstance = NULL; 
    if (!sharedInstance) { 
     Foo *temp = [[Foo alloc] init]; //NOTE: This MUST NOT have side effects for it to be threadsafe 
     if (!OSAtomicCompareAndSwapPtrBarrier(NULL, temp, &sharedInstance)) { 
      [temp release]; 
     } 
    } 
    return sharedInstance; 
} 

Answer 3

的singleton_remover功能不會做任何事情，因爲你已經覆蓋release什麼也不做。您的allocWithZone:方法在向共享實例發送retain時也會執行類似的無操作（並且完全忽略指定區域中的分配）。也許你應該有一個標誌來切換你的共享實例是否是無敵的（即不可釋放的）。

無論哪種方式，操作系統都會清理所有的內存。該文檔指出，操作系統只需要一次回收所有內存的速度要比您的應用程序逐漸回收速度快。

如果您共享實例是管理資源總是需要在您的應用程序終止時要清理，你應該有它的登記接收，並在那裏進行清理。

[[NSNotificationCenter defaultCenter] addObserver:self 
             selector:@selector(performCleanup:) 
              name:UIApplicationWillTerminateNotification 
              object:nil]; 

Answer 4

編輯

我包括這在上面，下面你可以看到我的歷史原貌的問題和實施。不過，我想我找到了最佳的方式爲用戶提供無鎖定開銷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 orig = @selector(sharedInstance); 
      SEL new = @selector(simpleSharedInstance); 
      Method origMethod = class_getClassMethod(self, orig); 
      Method newMethod = class_getClassMethod(self, new); 
      method_exchangeImplementations(origMethod, newMethod); 
     } 
    } 
    return (MySingleton *)sharedInstance; 
} 

---

和周圍的歷史討論初始化：

我現在看到原始代碼實際上與我的（下面）相似，除了對鎖外的實例進行檢查之外。

儘管新的+（void）初始化方法很有趣，但我不確定我更喜歡這個。現在看起來像現在要得到一個單身實例，你現在必須總是打電話：

MySingleton instance = [[MySingleton alloc] init]; 

這是不正確的？這感覺很奇怪，如果初始化的調用已經被鎖定了，它會更有效率嗎？雙鎖方法似乎對這個用例工作正常，同時也避免了鎖定（由於不止一個線程可能通過if），所以也避免了鎖定（由於雙分配的潛在代價，我認爲這是可能的）。

另一件看起來很奇怪的事情是，如果初始化方法真的很受歡迎，爲什麼我們在其他地方看不到呢？ Objective-C已經有很長的一段時間了，我對那些與所有已發表的例子不同的基本機制保持警惕。

我的代碼我目前使用的（這反映了我所看到的其他地方，包括this答案）：

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

+ (id)allocWithZone:(NSZone *)zone 
{ 
    @synchronized(self) 
    { 
     if (sharedInstance == nil) 
     { 
      sharedInstance = [super allocWithZone:zone]; 
      return sharedInstance; // assignment and return on first allocation 
     } 
    } 
    return nil; // on subsequent allocation attempts return nil 
} 

Answer 5

你的實現是線程安全的，似乎涵蓋所有的基礎（+初始化發送thread-由運行時安全）

編輯：很多代碼在atexit函數期間將不安全調用。在主線程上註冊更安全。

edit2：我已經蒸餾和提煉了我用到宏中的模式。在第一次調用-init時調用+sharedInstance，並在應用程序終止時調用-dealloc。

#define IMPLEMENT_UIAPP_SINGLETON(class_name) \ 
static class_name *shared ## class_name; \ 
+ (void)cleanupFromTerminate \ 
{ \ 
    class_name *temp = shared ## class_name; \ 
    shared ## class_name = nil; \ 
    [temp dealloc]; \ 
} \ 
+ (void)registerForCleanup \ 
{ \ 
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(cleanupFromTerminate) name:UIApplicationWillTerminateNotification object:nil]; \ 
} \ 
+ (void)initialize { \ 
    if (self == [class_name class]) { \ 
     NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; \ 
     if ([NSThread isMainThread]) \ 
      [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(cleanupFromTerminate) name:UIApplicationWillTerminateNotification object:nil]; \ 
     else \ 
      [self performSelectorOnMainThread:@selector(registerForCleanup) withObject:nil waitUntilDone:NO]; \ 
     shared ## class_name = [[super allocWithZone:NULL] init]; \ 
     [pool drain]; \ 
    } \ 
} \ 
+ (class_name *)sharedInstance \ 
{ \ 
    return shared ## class_name; \ 
} \ 
+ (id)allocWithZone:(NSZone *)zone \ 
{ \ 
    return shared ## class_name; \ 
} \ 
- (id)copyWithZone:(NSZone *)zone \ 
{ \ 
    return self; \ 
} \ 
- (id)retain \ 
{ \ 
    return self; \ 
} \ 
- (NSUInteger)retainCount \ 
{ \ 
    return NSUIntegerMax; \ 
} \ 
- (void)release \ 
{ \ 
} \ 
- (id)autorelease \ 
{ \ 
    return self; \ 
}