Se puoi scegliere come target iOS 4.0 o versioni successive

Usando GCD, è il modo migliore per creare singleton in Objective-C (thread-safe)?

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

Questo è un modo perfettamente accettabile e sicuro per creare un'istanza della tua classe. Tecnicamente potrebbe non essere un "singleton" (in quanto può esistere solo 1 di questi oggetti), ma fintanto che usi il [Foo sharedFoo]metodo solo per accedere all'oggetto, questo è abbastanza buono.

instanceType

instancetypeè solo una delle molte estensioni linguistiche a Objective-C, con altre aggiunte ad ogni nuova versione.

Conoscilo, lo adoro.

E prendilo come un esempio di come prestare attenzione ai dettagli di basso livello può darti informazioni su nuovi potenti modi di trasformare Objective-C.

Fare riferimento qui: instancetype

+ (instancetype)sharedInstance
{
    static dispatch_once_t once;
    static id sharedInstance;

    dispatch_once(&once, ^
    {
        sharedInstance = [self new];
    });    
    return sharedInstance;
}

+ (Class*)sharedInstance
{
    static dispatch_once_t once;
    static Class *sharedInstance;

    dispatch_once(&once, ^
    {
        sharedInstance = [self new];
    });    
    return sharedInstance;
}

MySingleton.h

@interface MySingleton : NSObject

+(instancetype)sharedInstance;

+(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")));
-(instancetype)copy __attribute__((unavailable("copy not available, call sharedInstance instead")));

@end

MySingleton.m

@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

È possibile evitare che la classe venga allocata sovrascrivendo il metodo alloc.

@implementation MyClass

static BOOL useinside = NO;
static id _sharedObject = nil;


+(id) alloc {
    if (!useinside) {
        @throw [NSException exceptionWithName:@"Singleton Vialotaion" reason:@"You are violating the singleton class usage. Please call +sharedInstance method" userInfo:nil];
    }
    else {
        return [super alloc];
    }
}

+(id)sharedInstance
{
    static dispatch_once_t p = 0;
    dispatch_once(&p, ^{
        useinside = YES;
        _sharedObject = [[MyClass alloc] init];
        useinside = NO;
    });   
    // returns the same object each time
    return _sharedObject;
}

Dave ha ragione, va benissimo. Potresti voler consultare i documenti di Apple sulla creazione di un singleton per suggerimenti sull'implementazione di alcuni degli altri metodi per garantire che solo uno possa mai essere creato se le classi scelgono di NON utilizzare il metodo sharedFoo.

Se vuoi assicurarti che [[MyClass alloc] init] restituisca lo stesso oggetto di sharedInstance (non necessario secondo me, ma alcuni lo vogliono), che può essere fatto molto facilmente e in sicurezza usando un secondo dispatch_once:

- (instancetype)init
{
    static dispatch_once_t once;
    static Class *sharedInstance;

    dispatch_once(&once, ^
    {
        // Your normal init code goes here. 
        sharedInstance = self;
    });

    return sharedInstance;
}

Ciò consente a qualsiasi combinazione di [[MyClass alloc] init] e [MyClass sharedInstance] di restituire lo stesso oggetto; [MyClass sharedInstance] sarebbe solo un po 'più efficiente. Come funziona: [MyClass sharedInstance] chiamerà [[MyClass alloc] init] una volta. Anche un altro codice potrebbe chiamarlo, un numero qualsiasi di volte. Il primo chiamante a init eseguirà l'inizializzazione "normale" e memorizzerà l'oggetto singleton nel metodo init. Qualsiasi chiamata successiva a init ignorerà completamente quale allocazione ha restituito e restituirà la stessa sharedInstance; il risultato dell'allocazione verrà deallocato.

Il metodo + sharedInstance funzionerà come sempre. Se non è il primo chiamante a chiamare [[MyClass alloc] init], il risultato di init non è il risultato della chiamata di allocazione, ma va bene.

Ti chiedi se questo è il "modo migliore per creare singleton".

Alcuni pensieri:

1. Innanzitutto, sì, questa è una soluzione thread-safe. Questo dispatch_oncemodello è il modo moderno e sicuro per generare singleton in Objective-C. Nessuna preoccupazione lì.

2. Hai chiesto, tuttavia, se questo è il modo "migliore" per farlo. Si dovrebbe riconoscere, tuttavia, che instancetypee [[self alloc] init]è potenzialmente fuorviante se utilizzato in combinazione con i singoli.

   Il vantaggio instancetypeè che è un modo inequivocabile di dichiarare che la classe può essere sottoclassata senza ricorrere a un tipo di id, come abbiamo dovuto fare in passato.

   Ma staticin questo metodo si presentano sfide di sottoclasse. E se ImageCachee i BlobCachesingoli fossero entrambe le sottoclassi di una Cachesuperclasse senza implementare il proprio sharedCachemetodo?

   ImageCache *imageCache = [ImageCache sharedCache];  // fine
   BlobCache *blobCache = [BlobCache sharedCache];     // error; this will return the aforementioned ImageCache!!!

   Perché questo funzioni, dovresti assicurarti che le sottoclassi implementino il loro sharedInstancemetodo (o come lo chiami per la tua classe particolare).

   In conclusione, l'originale sharedInstance sembra supportare le sottoclassi, ma non lo farà. Se si intende supportare la sottoclasse, almeno includere la documentazione che avverte i futuri sviluppatori che devono ignorare questo metodo.

3. Per una migliore interoperabilità con Swift, probabilmente si desidera definire questo come una proprietà, non un metodo di classe, ad esempio:

   @interface Foo : NSObject
   @property (class, readonly, strong) Foo *sharedFoo;
   @end

   Quindi puoi andare avanti e scrivere un getter per questa proprietà (l'implementazione utilizzerà il dispatch_oncemodello che hai suggerito):

   + (Foo *)sharedFoo { ... }

   Il vantaggio è che se un utente Swift lo usa, farebbe qualcosa del tipo:

   let foo = Foo.shared

   Nota, no (), perché l'abbiamo implementato come proprietà. A partire da Swift 3, in questo modo si accede generalmente ai singoli. Quindi definirlo come proprietà aiuta a facilitare tale interoperabilità.

   A parte questo, se osservi come Apple sta definendo i loro singoli, questo è lo schema che hanno adottato, ad esempio il loro NSURLSessionsingleton è definito come segue:

   @property (class, readonly, strong) NSURLSession *sharedSession;

4. Un'altra considerazione di interoperabilità di Swift molto minore era il nome del singleton. È meglio se puoi incorporare il nome del tipo, piuttosto che sharedInstance. Ad esempio, se la classe fosse Foo, è possibile definire la proprietà singleton come sharedFoo. O se la lezione fosse DatabaseManager, potresti chiamare la proprietà sharedManager. Quindi gli utenti Swift potrebbero fare:

   let foo = Foo.shared
   let manager = DatabaseManager.shared

   Chiaramente, se vuoi davvero usarlo sharedInstance, puoi sempre dichiarare il nome Swift se vuoi:

   @property (class, readonly, strong) Foo* sharedInstance NS_SWIFT_NAME(shared);

   Chiaramente, quando scriviamo il codice Objective-C, non dovremmo lasciare che l'interoperabilità di Swift superi altre considerazioni di progettazione, ma comunque, se possiamo scrivere un codice che supporta con grazia entrambi i linguaggi, è preferibile.

5. Concordo con gli altri che sottolineano che se si desidera che questo sia un vero singleton in cui gli sviluppatori non possono / non debbano (involontariamente) istanziare le proprie istanze, il unavailablequalificatore è attivo inited newè prudente.

Per creare un thread singolo sicuro puoi fare così:

@interface SomeManager : NSObject
+ (id)sharedManager;
@end

/* thread safe */
@implementation SomeManager

static id sharedManager = nil;

+ (void)initialize {
    if (self == [SomeManager class]) {
        sharedManager = [[self alloc] init];
    }
}

+ (id)sharedManager {
    return sharedManager;
}
@end

e questo blog spiega singleton singletons in objc / cacao

//Create Singleton  
  +( instancetype )defaultDBManager
    {

        static dispatch_once_t onceToken = 0;
        __strong static id _sharedObject = nil;

        dispatch_once(&onceToken, ^{
            _sharedObject = [[self alloc] init];
        });

        return _sharedObject;
    }


//In it method
-(instancetype)init
{
    self = [super init];
  if(self)
     {
   //Do your custom initialization
     }
     return self;
}

@interface className : NSObject{
+(className*)SingleTonShare;
}

@implementation className

+(className*)SingleTonShare{

static className* sharedObj = nil;
static dispatch_once_t once = 0;
dispatch_once(&once, ^{

if (sharedObj == nil){
    sharedObj = [[className alloc] init];
}
  });
     return sharedObj;
}