Singleton mit ARC

Dem Schlüsselwort selbst innerhalb einer Methode verweist auf die Eigentümer der Methode, die die Instanz ist, die das Objekt für die Instanz-Methoden und die Klasse für die Klasse Methoden. Jedoch, die Nachricht saveContex fehlt ein t am Ende (saveContext).

dispatch_once singleton

Und hier ist eine bessere singleton-idiom kompatibel mit ARC:

+(MySingleton *)sharedInstance {
    static dispatch_once_t pred;
    static MySingleton *shared = nil;
    dispatch_once(&pred, ^{
        shared = [[MySingleton alloc] init];
    });
    return shared;
}

Gleichen code wie Xcode-Vorlage

Denselben code wie eine Xcode-Vorlage mit Platzhaltern:

+ (<#class#> *)shared<#name#> {
    static dispatch_once_t onceToken;
    static <#class#> *shared<#name#> = nil;
    dispatch_once(&onceToken, ^{
        shared<#name#> = <#initializer#>;
    });
    return shared<#name#>;
}

Gleichen code + deaktiviert alloc/init/neue

Wollen Hinweis die Benutzer, die Sie anrufen sollte sharedInstance statt alloc/init/neue? Sie können deaktivieren Sie die Methoden mit dem Attribut " nicht verfügbar. Dies führt zu einer compiler-Fehlermeldung, wenn eine dieser Methoden aufgerufen wird, die auf die Klasse.

#import <Foundation/Foundation.h>

@interface MySingleton : NSObject

+(instancetype) sharedInstance;

//clue for improper use (produces compile time error)
+(instancetype) alloc __attribute__((unavailable("alloc not available, call sharedInstance instead")));
-(instancetype) init __attribute__((unavailable("init not available, call sharedInstance instead")));
+(instancetype) new __attribute__((unavailable("new not available, call sharedInstance instead")));

@end

#import "MySingleton.h"

@implementation MySingleton

+(instancetype) sharedInstance {
    static dispatch_once_t pred;
    static id shared = nil;
    dispatch_once(&pred, ^{
        shared = [[super alloc] initUniqueInstance];
    });
    return shared;
}

-(instancetype) initUniqueInstance {
    return [super init];
}

@end

Warnung: dispatch_once ist nicht reentrant

Machen Sie nicht einen rekursiven Aufruf sharedInstance aus dem inneren der dispatch_once block.

Wenn Sie anrufen dispatch_once aus mehreren threads, die es fungiert als ein Hindernis für den gleichzeitigen Zugriff. Aber wenn Sie rufen es wieder in dem selben thread, aus in den block, es wird deadlock thread. Dieses Beispiel veranschaulicht das problem:

#import <Foundation/Foundation.h>

static NSRecursiveLock *_lock = nil;
//constructor = run before main. used = emit code even if the function is not referenced.
//See http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
static void runBeforeMain(void) __attribute__ ((constructor, used));
static void runBeforeMain(void) {
    _lock = [NSRecursiveLock new];
}

static void test(void) 
{
    static NSUInteger count = 0;
    NSLog(@"iteration #%lu", ++count);

    //WRONG: deadlock!
    //static dispatch_once_t token;
    //dispatch_once(&token, ^{
    // test();
    //});

    //OK
    [_lock lock];
    test();
    [_lock unlock];

    --count;
}

int main(int argc, char **argv) {
    @autoreleasepool {
        test();
    }
    return EXIT_SUCCESS;
}

+initialisieren singleton

Mit +initialisieren ist eine alternative idiom zum erstellen einer singleton. Vorteile: Es ist um ein Vielfaches schneller als dispatch_once. Nachteile: +initialize heißt einmal pro Klasse, so dass, wenn Sie eine Unterklasse der singleton ist, wird eine Instanz erstellt werden, die für jede übergeordnete Klasse zu. Verwenden Sie es nur, wenn Sie wissen das singleton nicht untergeordnet.

static id sharedInstance;

+ (void) initialize {
    //subclassing would result in an instance per class, probably not what we want
    NSAssert([MySingleton class] == self, @"Subclassing is not welcome");
    sharedInstance = [[super alloc] initUniqueInstance];
}

+(instancetype) sharedInstance {
    return sharedInstance;
}

InformationsquelleAutor der Antwort Jano