Jak powinien wyglądać mój singleton Objective-C? [Zamknięte]

Moja metoda akcesorium singleton jest zwykle pewnym wariantem:

static MyClass *gInstance = NULL;

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

    return(gInstance);
}

Co mogę zrobić, aby to poprawić?

Inną opcją jest użycie +(void)initializemetody. Z dokumentacji:

Środowisko wykonawcze wysyła initializedo każdej klasy w programie dokładnie jeden raz tuż przed klasą lub dowolną klasą, która z niej dziedziczy, wysyłana jest pierwsza wiadomość z poziomu programu. (W związku z tym nigdy nie można wywołać metody, jeśli klasa nie jest używana.) Środowisko wykonawcze wysyła initializekomunikat do klas w sposób bezpieczny dla wątków. Nadklasy otrzymują ten komunikat przed podklasami.

Możesz więc zrobić coś podobnego do tego:

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

[Źródło]

Według mojej innej odpowiedzi poniżej, myślę, że powinieneś zrobić:

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

Ponieważ Kendall opublikował bezpieczny wątek, który próbuje uniknąć kosztów blokowania, pomyślałem, że też go podrzucę:

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

OK, pozwól mi wyjaśnić, jak to działa:

1. Szybki przypadek: w normalnym wykonaniu sharedInstancezostała już ustawiona, więc whilepętla nigdy nie jest wykonywana, a funkcja powraca po zwykłym sprawdzeniu istnienia zmiennej;

2. Wolna sprawa: jeśli sharedInstancenie istnieje, to instancja jest przydzielana i kopiowana do niej za pomocą funkcji porównania i zamiany („CAS”);

3. Przypadek sporny: jeśli dwa wątki próbują zadzwonić sharedInstancew tym samym czasie ORAZ sharedInstance nie istnieje w tym samym czasie, oba zainicjują nowe wystąpienia singletonu i podejmą próbę umieszczenia go w CAS. Cokolwiek wygrywa, CAS natychmiast zwraca, cokolwiek traci, zwalnia właśnie przydzieloną instancję i zwraca (teraz ustawione) sharedInstance. Singiel OSAtomicCompareAndSwapPtrBarrierdziała zarówno jako bariera zapisu dla wątku ustawiającego, jak i bariera odczytu dla wątku testowego.

static MyClass * sharedInst = zero;

+ (id) sharedInstance
{
    @synchronize (self) {
        if (sharedInst == zero) {
            / * sharedInst skonfigurowane w init * /
            [[samodzielny przydział] init];
        }
    }
    return sharedInst;
}

- (id) init
{
    if (sharedInst! = zero) {
        [Podniesienie NSException: NSInternalInconsistencyException
            format: @ "Nie można wywołać [% @% @]; zamiast tego użyj + [% @% @]"],
            NSStringFromClass ([self class]), NSStringFromSelector (_cmd), 
            NSStringFromClass ([self class]),
            NSStringFromSelector (@selector (sharedInstance) "];
    } else if (self = [super init]) {
        sharedInst = self;
        / * Bez względu na klasę tutaj * /
    }
    return sharedInst;
}

/ * Te prawdopodobnie nic nie robią
   aplikacja GC. Utrzymuje singleton
   jako faktyczny singleton w
   aplikacja inna niż CG
* /
- (NSUInteger) retainCount
{
    return NSUIntegerMax;
}

- Zwolnienie (w jedną stronę)
{
}

- (id) zachowaj
{
    return sharedInst;
}

- (id) autorelease
{
    return sharedInst;
}

Edycja: Ta implementacja jest przestarzała z ARC. Zobacz, jak zaimplementować singleton Objective-C zgodny z ARC? dla prawidłowego wdrożenia.

Wszystkie implementacje inicjalizacji, które przeczytałem w innych odpowiedziach, mają wspólny błąd.

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

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

Dokumentacja Apple zaleca sprawdzenie typu klasy w bloku inicjalizacji. Ponieważ podklasy domyślnie wywołują inicjalizację. Istnieje nieoczywisty przypadek, w którym podklasy można tworzyć pośrednio za pośrednictwem KVO. Bo jeśli dodasz następujący wiersz w innej klasie:

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

Cel C domyślnie utworzy podklasę MySingletonClass, co spowoduje drugie wyzwolenie +initialize.

Możesz pomyśleć, że niejawnie powinieneś sprawdzić duplikat inicjalizacji w swoim bloku init jako taki:

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

Ale zastrzelicie się w stopę; lub, co gorsza, dać innemu deweloperowi możliwość zastrzelenia się w stopę.

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

TL; DR, oto moja implementacja

@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

(Zamień ZAssert na własne makro asercji; lub po prostu NSAssert.)

Dokładne wyjaśnienie kodu makr Singleton znajduje się na blogu Cocoa With Love

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

Mam ciekawą odmianę sharedInstance, która jest bezpieczna dla wątków, ale nie blokuje się po inicjalizacji. Nie jestem jeszcze wystarczająco pewny, aby zmodyfikować najwyższą odpowiedź zgodnie z żądaniem, ale przedstawiam ją do dalszej dyskusji:

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

Krótka odpowiedź: fantastycznie.

Długa odpowiedź: coś w stylu ....

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

Przeczytaj nagłówek dispatch / once.h, aby zrozumieć, co się dzieje. W takim przypadku komentarze nagłówka są bardziej odpowiednie niż dokumenty lub strona podręcznika man.

Przekształciłem singletona w klasę, aby inne klasy mogły dziedziczyć właściwości singletonu.

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

A oto przykład jakiejś klasy, w której chcesz zostać singlem.

#import "Singleton.h"

@interface SomeClass : Singleton {

}

@end

@implementation SomeClass 

DEFINE_SHARED_INSTANCE;

@end

Jedynym ograniczeniem dotyczącym klasy Singleton jest to, że jest to podklasa NSObject. Ale przez większość czasu używam singletonów w kodzie, w rzeczywistości są to podklasy NSObject, więc ta klasa naprawdę ułatwia mi życie i czyni kod czystszym.

Działa to również w środowisku bez śmieci.

@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

Czy nie powinno to być bezpieczne dla wątków i uniknąć kosztownego blokowania po pierwszym połączeniu?

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

Oto makro, które zestawiłem:

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

Opiera się na pracy Matta Gallaghera. Ale zmiana implementacji na użycie metody swizzling, jak opisano tutaj przez Dave'a MacLachlana z Google .

Z zadowoleniem przyjmuję komentarze / uwagi.

Co powiesz na

static MyClass *gInstance = NULL;

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

    return(gInstance);
}

Więc unikasz kosztów synchronizacji po inicjalizacji?

Aby uzyskać dogłębną dyskusję na temat wzoru singletonu w celu C, zajrzyj tutaj:

Używanie wzorca singletonu w celu C

KLSingleton to:

1. Podklasa (do n-tego stopnia)
2. Kompatybilny z ARC
3. Bezpiecznie z allociinit
4. Załadowane leniwie
5. Bezpieczny dla wątków
6. Bez blokady (używa + inicjalizacji, a nie @synchronize)
7. Bez makr
8. Swizzle-free
9. Prosty

KLSingleton

Nie chcesz synchronizować na sobie ... Ponieważ obiekt self jeszcze nie istnieje! W rezultacie blokujesz tymczasową wartość identyfikatora. Chcesz mieć pewność, że nikt inny nie będzie mógł uruchamiać metod klasowych (sharedInstance, alokacja, alokacjaWithZone: itd.), Więc zamiast tego musisz zsynchronizować obiekt klasy:

@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

Chciałem to zostawić tutaj, żeby tego nie zgubić. Zaletą tego jest to, że można go używać w InterfaceBuilder, co jest OGROMNĄ zaletą. To pochodzi z innego pytania, które zadałem :

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

Wiem, że jest wiele komentarzy na temat tego „pytania”, ale nie widzę wielu osób sugerujących użycie makra do zdefiniowania singletonu. To taki powszechny wzorzec, a makro znacznie upraszcza singleton.

Oto makra, które napisałem na podstawie kilku implementacji Objc, które widziałem.

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

Przykład zastosowania:

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

Po co makro interfejsu, gdy jest prawie puste? Spójność kodu między nagłówkiem a plikami kodu; łatwość konserwacji w przypadku, gdy chcesz dodać więcej automatycznych metod lub zmienić je.

Korzystam z metody inicjalizacji, aby utworzyć singleton, tak jak jest to stosowane w najpopularniejszej odpowiedzi tutaj (w momencie pisania).

Dzięki metodom klasy Objective C możemy po prostu uniknąć używania wzorca singletonu w zwykły sposób, z:

[[Librarian sharedInstance] openLibrary]

do:

[Librarian openLibrary]

przez zawinięcie klasy w inną klasę, która ma tylko metody klasowe , w ten sposób nie ma szansy na przypadkowe utworzenie duplikatów, ponieważ nie tworzymy żadnej!

Bardziej szczegółowy blog napisałem tutaj :)

Aby rozszerzyć przykład z @ 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;
}

Moja droga jest prosta:

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

Jeśli singleton jest już zainicjowany, blok LOCK nie zostanie wprowadzony. Drugim sprawdzeniem, czy (! Zainicjowano) jest upewnienie się, że nie jest jeszcze inicjalizowane, gdy bieżący wątek nabywa LOCK.

Nie przeczytałem wszystkich rozwiązań, więc wybacz, jeśli ten kod jest zbędny.

To moim zdaniem najbardziej bezpieczna implementacja wątków.

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

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

    return sharedResourcesObj;
}

Zwykle używam kodu z grubsza podobnego do tego w odpowiedzi Bena Hoffsteina (który również dostałem z Wikipedii). Używam go z powodów podanych przez Chrisa Hansona w jego komentarzu.

Czasami jednak muszę umieścić singletona w NIB, a w takim przypadku używam:

@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

Implementację -retain(itp.) Pozostawiam czytelnikowi, chociaż powyższy kod jest wszystkim, czego potrzebujesz w środowisku śmieci.

Przyjęta odpowiedź, choć się kompiluje, jest niepoprawna.

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

Dokumentacja według Apple:

... Możesz zastosować podobne podejście, aby zsynchronizować metody klas powiązanych klas, używając obiektu Class zamiast self.

Nawet jeśli korzystam z self działa, nie powinno, a to wygląda na błąd kopiowania i wklejania. Prawidłowa implementacja metody klasy fabryki to:

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