Si puede apuntar a iOS 4.0 o superior

Usando GCD, ¿es la mejor manera de crear singleton en Objective-C (hilo seguro)?

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

Esta es una manera perfectamente aceptable y segura para crear una instancia de su clase. Puede que técnicamente no sea un "singleton" (en el sentido de que solo puede haber 1 de estos objetos), pero siempre que solo use el [Foo sharedFoo]método para acceder al objeto, esto es lo suficientemente bueno.

tipo de instancia

instancetypees solo una de las muchas extensiones de idioma Objective-C, y se agregan más con cada nueva versión.

Conócelo, ámalo.

Y tómelo como un ejemplo de cómo prestar atención a los detalles de bajo nivel puede brindarle información sobre nuevas y poderosas formas de transformar Objective-C.

Consulte aquí: tipo de instancia

+ (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

Puede evitar que la clase se asigne sobrescribiendo el método de asignación.

@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 tiene razón, eso está perfectamente bien. Es posible que desee consultar los documentos de Apple sobre cómo crear un singleton para obtener consejos sobre la implementación de algunos de los otros métodos para garantizar que solo se pueda crear uno si las clases eligen NO usar el método sharedFoo.

Si desea asegurarse de que [[MyClass alloc] init] devuelve el mismo objeto que sharedInstance (no es necesario en mi opinión, pero algunas personas lo quieren), eso se puede hacer de manera muy fácil y segura usando un segundo 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;
}

Esto permite que cualquier combinación de [[MyClass alloc] init] y [MyClass sharedInstance] devuelva el mismo objeto; [MyClass sharedInstance] sería un poco más eficiente. Cómo funciona: [MyClass sharedInstance] llamará [[MyClass alloc] init] una vez. Otro código podría llamarlo también, cualquier cantidad de veces. La primera persona que llama a init hará la inicialización "normal" y almacenará el objeto singleton en el método init. Cualquier llamada posterior a init ignorará por completo qué asignación devolvió y devolverá la misma SharedInstance; El resultado de alloc será desasignado.

El método + sharedInstance funcionará como siempre. Si no es la primera persona que llama en llamar a [[MyClass alloc] init], entonces el resultado de init no es el resultado de la llamada de asignación, pero eso está bien.

Pregunta si esta es la "mejor manera de crear singleton".

Algunas reflexiones:

1. Primero, sí, esta es una solución segura para subprocesos. Este dispatch_oncepatrón es la forma moderna y segura de subprocesos para generar tonos únicos en Objective-C. No te preocupes allí.

2. Sin embargo, usted preguntó si esta es la "mejor" forma de hacerlo. Sin embargo, uno debería reconocer que el instancetypey [[self alloc] init]es potencialmente engañoso cuando se usa junto con singletons.

   El beneficio instancetypees que es una forma inequívoca de declarar que la clase puede subclasificarse sin recurrir a un tipo de id, como teníamos que hacer en el pasado.

   Pero staticen este método presenta desafíos de subclases. ¿Qué pasaría si ImageCachey los BlobCachesingletons fueran ambas subclases de una Cachesuperclase sin implementar su propio sharedCachemétodo?

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

   Para que esto funcione, debe asegurarse de que las subclases implementen su propio sharedInstancemétodo (o como lo llame para su clase particular).

   En pocas palabras, sharedInstance parece que su original admitirá subclases, pero no lo hará. Si tiene la intención de admitir subclases, al menos incluya documentación que advierta a los futuros desarrolladores que deben anular este método.

3. Para una mejor interoperabilidad con Swift, probablemente desee definir esto como una propiedad, no un método de clase, por ejemplo:

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

   Luego puede continuar y escribir un captador para esta propiedad (la implementación usaría el dispatch_oncepatrón que sugirió):

   + (Foo *)sharedFoo { ... }

   El beneficio de esto es que si un usuario de Swift va a usarlo, haría algo como:

   let foo = Foo.shared

   Tenga en cuenta que no hay (), porque lo implementamos como una propiedad. Iniciando Swift 3, así es como generalmente se accede a los singletons. Por lo tanto, definirlo como una propiedad ayuda a facilitar esa interoperabilidad.

   Además, si observa cómo Apple está definiendo sus singletons, este es el patrón que han adoptado, por ejemplo, su NSURLSessionsingleton se define de la siguiente manera:

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

4. Otra consideración de interoperabilidad Swift muy menor fue el nombre del singleton. Es mejor si puede incorporar el nombre del tipo, en lugar de sharedInstance. Por ejemplo, si la clase era Foo, podría definir la propiedad singleton como sharedFoo. O si la clase fuera DatabaseManager, podría llamar a la propiedad sharedManager. Entonces los usuarios de Swift podrían hacer:

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

   Claramente, si realmente desea usar sharedInstance, siempre puede declarar el nombre de Swift si desea:

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

   Claramente, al escribir código Objective-C, no debemos permitir que la interoperabilidad de Swift supere otras consideraciones de diseño, pero aún así, si podemos escribir código que admita ambos lenguajes con gracia, es preferible.

5. Estoy de acuerdo con otros que señalan que si quieres que esto sea un verdadero singleton donde los desarrolladores no pueden / no deben (accidentalmente) crear instancias de sus propias instancias, el unavailablecalificador está activado inity newes prudente.

Para crear singleton seguro para subprocesos puede hacer lo siguiente:

@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

y este blog explica singleton muy bien singletons en objc / cocoa

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