Wie sollte mein Objective-C-Singleton aussehen? [geschlossen]

Meine Singleton-Accessor-Methode ist normalerweise eine Variante von:

static MyClass *gInstance = NULL;

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

    return(gInstance);
}

Was könnte ich tun, um dies zu verbessern?

Eine andere Möglichkeit ist die Verwendung der +(void)initializeMethode. Aus der Dokumentation:

Die Laufzeit wird initializegenau einmal an jede Klasse in einem Programm gesendet, kurz bevor die Klasse oder eine von ihr geerbte Klasse ihre erste Nachricht aus dem Programm heraus sendet . (Daher wird die Methode möglicherweise nie aufgerufen, wenn die Klasse nicht verwendet wird.) Die Laufzeit sendet die initializeNachricht threadsicher an Klassen. Superklassen erhalten diese Nachricht vor ihren Unterklassen.

Sie könnten also etwas Ähnliches tun:

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

[Quelle]

Gemäß meiner anderen Antwort unten denke ich, dass Sie tun sollten:

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

Da Kendall einen threadsicheren Singleton veröffentlicht hat, der versucht, Sperrkosten zu vermeiden, dachte ich, ich würde auch einen werfen:

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

Okay, lassen Sie mich erklären, wie das funktioniert:

1. Schneller Fall: In der normalen Ausführung sharedInstancewurde bereits festgelegt, sodass die whileSchleife niemals ausgeführt wird und die Funktion nach einfachem Testen der Existenz der Variablen zurückkehrt.

2. Langsamer Fall: Wenn sharedInstancenicht vorhanden, wird eine Instanz zugewiesen und mithilfe von Compare And Swap ('CAS') in diese kopiert.

3. Stritten Fall: Wenn zwei Threads beide Versuch Aufruf sharedInstancezur gleichen Zeit und sharedInstance existiert nicht in der gleichen Zeit , dann werden sie beiden initialize neuen Instanzen der Singleton und versuchen, CAS es in der richtigen Position. Wer auch immer den CAS gewinnt, gibt sofort zurück, wer verliert, gibt die gerade zugewiesene Instanz frei und gibt die (jetzt gesetzte) zurück sharedInstance. Die Single OSAtomicCompareAndSwapPtrBarrierfungiert sowohl als Schreibbarriere für den Einstellungs-Thread als auch als Lesebarriere für den Test-Thread.

statische MyClass * sharedInst = nil;

+ (id) sharedInstance
{
    @synchronize (self) {
        if (sharedInst == nil) {
            / * sharedInst in init eingerichtet * /
            Selbstzuweisung init;
        }}
    }}
    return sharedInst;
}}

- (id) init
{
    if (sharedInst! = nil) {
        [NSException erhöhen: NSInternalInconsistencyException
            Format: @ "[% @% @] kann nicht aufgerufen werden; verwenden Sie stattdessen + [% @% @]"],
            NSStringFromClass ([Selbstklasse]), NSStringFromSelector (_cmd), 
            NSStringFromClass ([Selbstklasse]),
            NSStringFromSelector (@selector (sharedInstance) "];
    } else if (self = [super init]) {
        sharedInst = self;
        / * Welche Klasse auch immer hier spezifisch ist * /
    }}
    return sharedInst;
}}

/ * Diese machen wahrscheinlich nichts in
   eine GC-App. Hält Singleton
   als tatsächlicher Singleton in a
   Nicht-CG-App
* /
- (NSUInteger) keepCount
{
    return NSUIntegerMax;
}}

- (Einweg ungültig) Freigabe
{
}}

- (id) behalten
{
    return sharedInst;
}}

- (id) Autorelease
{
    return sharedInst;
}}

Bearbeiten: Diese Implementierung ist mit ARC veraltet. Schauen Sie sich bitte an, wie ich einen Objective-C-Singleton implementiere, der mit ARC kompatibel ist. für die korrekte Umsetzung.

Alle Implementierungen von initialize, die ich in anderen Antworten gelesen habe, haben einen gemeinsamen Fehler.

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

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

In der Apple-Dokumentation wird empfohlen, den Klassentyp in Ihrem Initialisierungsblock zu überprüfen. Weil Unterklassen standardmäßig die Initialisierung aufrufen. Es gibt einen nicht offensichtlichen Fall, in dem Unterklassen indirekt über KVO erstellt werden können. Wenn Sie die folgende Zeile in eine andere Klasse einfügen:

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

Objective-C erstellt implizit eine Unterklasse von MySingletonClass, was zu einer zweiten Auslösung von führt +initialize.

Möglicherweise sollten Sie implizit prüfen, ob Ihr Init-Block als solcher doppelt initialisiert ist:

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

Aber du wirst dich in den Fuß schießen; oder schlimmer noch, geben Sie einem anderen Entwickler die Möglichkeit, sich in den Fuß zu schießen.

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

TL; DR, hier ist meine Implementierung

@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

(Ersetzen Sie ZAssert durch unser eigenes Assertionsmakro oder nur durch NSAssert.)

Eine ausführliche Erklärung des Singleton-Makrocodes finden Sie im Blog Cocoa With Love

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

Ich habe eine interessante Variante von sharedInstance, die threadsicher ist, aber nach der Initialisierung nicht gesperrt wird. Ich bin mir noch nicht sicher genug, um die Top-Antwort wie gewünscht zu ändern, aber ich präsentiere sie zur weiteren Diskussion:

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

Kurze Antwort: Fabelhaft.

Lange Antwort: So etwas wie ....

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

Lesen Sie unbedingt die Kopfzeile dispatch / einmal.h, um zu verstehen, was los ist. In diesem Fall sind die Header-Kommentare zutreffender als die Dokumente oder die Manpage.

Ich habe Singleton in eine Klasse gerollt, damit andere Klassen Singleton-Eigenschaften erben können.

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

Und hier ist ein Beispiel für eine Klasse, die Sie Singleton werden möchten.

#import "Singleton.h"

@interface SomeClass : Singleton {

}

@end

@implementation SomeClass 

DEFINE_SHARED_INSTANCE;

@end

Die einzige Einschränkung der Singleton-Klasse besteht darin, dass es sich um eine NSObject-Unterklasse handelt. Aber meistens verwende ich Singletons in meinem Code, es handelt sich tatsächlich um NSObject-Unterklassen. Diese Klasse erleichtert mir also das Leben und macht den Code sauberer.

Dies funktioniert auch in einer Umgebung ohne Müllabfuhr.

@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

Sollte dies nicht threadsicher sein und das teure Sperren nach dem ersten Anruf vermeiden?

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

Hier ist ein Makro , das ich zusammengestellt habe:

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

Es basiert auf der Arbeit von Matt Gallagher. Die Implementierung wurde jedoch geändert, um die hier von Dave MacLachlan von Google beschriebene Methode Swizzling zu verwenden .

Ich freue mich über Kommentare / Beiträge.

Wie wäre es mit

static MyClass *gInstance = NULL;

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

    return(gInstance);
}

So vermeiden Sie die Synchronisationskosten nach der Initialisierung?

Eine ausführliche Beschreibung des Singleton-Musters in Objective-C finden Sie hier:

Verwenden des Singleton-Musters in Objective-C

KLSingleton ist:

1. Unterklassifizierbar (bis zum n-ten Grad)
2. ARC-kompatibel
3. Sicher mit allocundinit
4. Faul geladen
5. Gewindesicher
6. Lock-free (verwendet + initialize, nicht @synchronize)
7. Makrofrei
8. Swizzle-frei
9. Einfach

KLSingleton

Sie möchten nicht mit sich selbst synchronisieren ... Da das Selbstobjekt noch nicht existiert! Am Ende sperren Sie einen temporären ID-Wert. Sie möchten sicherstellen, dass niemand anderes Klassenmethoden ausführen kann (sharedInstance, alloc, allocWithZone:, usw.). Daher müssen Sie stattdessen das Klassenobjekt synchronisieren:

@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

Ich wollte das nur hier lassen, damit ich es nicht verliere. Der Vorteil von diesem ist, dass es in InterfaceBuilder verwendet werden kann, was ein RIESIGER Vorteil ist. Dies geht aus einer anderen Frage hervor, die ich gestellt habe :

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

Ich weiß, dass es viele Kommentare zu dieser "Frage" gibt, aber ich sehe nicht viele Leute, die vorschlagen, ein Makro zu verwenden, um den Singleton zu definieren. Es ist so ein allgemeines Muster und ein Makro vereinfacht den Singleton erheblich.

Hier sind die Makros, die ich basierend auf mehreren Objc-Implementierungen geschrieben habe, die ich gesehen habe.

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

Anwendungsbeispiel:

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

Warum ein Schnittstellenmakro, wenn es fast leer ist? Codekonsistenz zwischen Header- und Codedateien; Wartbarkeit für den Fall, dass Sie weitere automatische Methoden hinzufügen oder ändern möchten.

Ich verwende die Initialisierungsmethode, um den Singleton zu erstellen, wie er in der beliebtesten Antwort hier (zum Zeitpunkt des Schreibens) verwendet wird.

Mit Objective C-Klassenmethoden können wir einfach vermeiden, das Singleton-Muster auf die übliche Weise zu verwenden:

[[Librarian sharedInstance] openLibrary]

zu:

[Librarian openLibrary]

Wenn Sie die Klasse in eine andere Klasse einbinden , die nur über Klassenmethoden verfügt, besteht keine Möglichkeit, versehentlich doppelte Instanzen zu erstellen, da wir keine Instanz erstellen!

Ich schrieb einen detaillierteren Blog hier :)

Um das Beispiel von @ robbie-hanson zu erweitern ...

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

Mein Weg ist so einfach:

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

Wenn der Singleton bereits initialisiert ist, wird der LOCK-Block nicht eingegeben. Die zweite Überprüfung, ob (! Initialisiert) ist, um sicherzustellen, dass es noch nicht initialisiert ist, wenn der aktuelle Thread das LOCK erhält.

Ich habe nicht alle Lösungen durchgelesen. Verzeihen Sie also, ob dieser Code redundant ist.

Dies ist meiner Meinung nach die thread-sicherste Implementierung.

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

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

    return sharedResourcesObj;
}

Normalerweise verwende ich Code, der dem in Ben Hoffsteins Antwort (die ich auch aus Wikipedia erhalten habe) in etwa ähnlich ist. Ich benutze es aus den Gründen, die Chris Hanson in seinem Kommentar angegeben hat.

Manchmal muss ich jedoch einen Singleton in eine NIB einfügen, und in diesem Fall verwende ich Folgendes:

@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

Ich überlasse die Implementierung von -retain(usw.) dem Leser, obwohl der obige Code alles ist, was Sie in einer Müllsammelumgebung benötigen.

Die akzeptierte Antwort ist zwar kompiliert, aber falsch.

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

Gemäß Apple-Dokumentation:

... Sie können einen ähnlichen Ansatz verwenden, um die Klassenmethoden der zugeordneten Klasse zu synchronisieren, indem Sie das Class-Objekt anstelle von self verwenden.

Selbst wenn die Verwendung von Self funktioniert, sollte dies nicht der Fall sein, und dies scheint mir ein Fehler beim Kopieren und Einfügen zu sein. Die korrekte Implementierung für eine Klassenfactory-Methode wäre:

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