Se você pode segmentar o iOS 4.0 ou superior

Usando o GCD, é a melhor maneira de criar singleton no Objective-C (thread safe)?

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

Essa é uma maneira perfeitamente aceitável e segura de thread para criar uma instância da sua classe. Tecnicamente, pode não ser um "singleton" (já que só pode haver um desses objetos), mas desde que você use apenas o [Foo sharedFoo]método para acessar o objeto, isso é bom o suficiente.

instancetype

instancetypeé apenas uma das muitas extensões de idioma para Objective-C, com mais sendo adicionadas a cada nova versão.

Conheça, ame.

E tome como exemplo de como prestar atenção aos detalhes de baixo nível pode fornecer insights sobre novas e poderosas maneiras de transformar o Objective-C.

Consulte aqui: 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

Você pode evitar que a classe seja alocada substituindo o método de atribuição.

@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 está correto, está perfeitamente bem. Você pode consultar os documentos da Apple sobre a criação de um singleton para obter dicas sobre como implementar alguns dos outros métodos para garantir que apenas um possa ser criado se as classes optarem por NÃO usar o método sharedFoo.

Se você quer ter certeza de que [[MyClass aloc] init] retorna o mesmo objeto que sharedInstance (não é necessário na minha opinião, mas algumas pessoas querem isso), isso pode ser feito com muita facilidade e segurança usando um 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;
}

Isso permite que qualquer combinação de [[MyClass alocado] init] e [MyClass sharedInstance] retorne o mesmo objeto; [MyClass sharedInstance] seria apenas um pouco mais eficiente. Como funciona: [MyClass sharedInstance] chamará [[MyClass shared] init] uma vez. Outro código poderia chamá-lo também, inúmeras vezes. O primeiro chamador a init fará a inicialização "normal" e armazenará o objeto singleton no método init. Quaisquer chamadas posteriores ao init ignorarão completamente o que a alocação retornou e retornará a mesma sharedInstance; o resultado da alocação será desalocado.

O método + sharedInstance funcionará como sempre. Se não for o primeiro chamador a ligar para [[MyClass assign] init], o resultado do init não será o resultado da chamada de alocação, mas tudo bem.

Você pergunta se esta é a "melhor maneira de criar singleton".

Algumas reflexões:

1. Primeiro, sim, esta é uma solução segura para threads. Esse dispatch_oncepadrão é a maneira moderna e segura de thread de gerar singletons no Objective-C. Não se preocupe lá.

2. Você perguntou, porém, se essa é a "melhor" maneira de fazer isso. Deve-se reconhecer, porém, que o instancetypee [[self alloc] init]é potencialmente enganoso quando usado em conjunto com singletons.

   O benefício instancetypedisso é que é uma maneira inequívoca de declarar que a classe pode ser subclassificada sem recorrer a um tipo de id, como tivemos que fazer no passado.

   Mas o staticmétodo apresenta desafios de subclassificação. E se ImageCachee BlobCachesingletons fossem subclasses de uma Cachesuperclasse sem implementar seu próprio sharedCachemétodo?

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

   Para que isso funcione, você deve garantir que as subclasses implementem seu próprio sharedInstancemétodo (ou o que você chamar para sua classe específica).

   Resumindo, seu original sharedInstance parece suportar subclasses, mas não. Se você pretende dar suporte à subclasse, inclua pelo menos a documentação que avisa os desenvolvedores futuros que eles devem substituir esse método.

3. Para melhor interoperabilidade com o Swift, você provavelmente deseja definir isso como uma propriedade, não um método de classe, por exemplo:

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

   Em seguida, você pode prosseguir e escrever um getter para essa propriedade (a implementação usaria o dispatch_oncepadrão sugerido):

   + (Foo *)sharedFoo { ... }

   O benefício disso é que, se um usuário Swift for usá-lo, ele fará algo como:

   let foo = Foo.shared

   Observe que não existe (), porque nós o implementamos como uma propriedade. A partir do Swift 3, é assim que os singletons são geralmente acessados. Portanto, defini-lo como uma propriedade ajuda a facilitar essa interoperabilidade.

   Como um aparte, se você observar como a Apple está definindo seus singletons, esse é o padrão que eles adotaram, por exemplo, seu NSURLSessionsingleton é definido da seguinte maneira:

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

4. Outra consideração muito pequena sobre a interoperabilidade Swift foi o nome do singleton. É melhor se você pode incorporar o nome do tipo em vez de sharedInstance. Por exemplo, se a classe era Foo, você pode definir a propriedade singleton como sharedFoo. Ou, se a classe fosse DatabaseManager, você poderia chamar a propriedade sharedManager. Os usuários do Swift poderiam fazer:

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

   Claramente, se você realmente deseja usar sharedInstance, sempre pode declarar o nome Swift, se desejar:

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

   Claramente, ao escrever o código Objective-C, não devemos permitir que a interoperabilidade Swift supere outras considerações de design, mas ainda assim, se pudermos escrever código que suporte graciosamente os dois idiomas, é preferível.

5. Concordo com os outros que apontam que, se você quer que isso seja um verdadeiro singleton onde os desenvolvedores não pode / não deve (acidentalmente) instanciar suas próprias instâncias, o unavailablequalificador no inite newé prudente.

Para criar um singleton seguro para threads, faça o seguinte:

@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 este blog explica singleton muito bem singletons em objc / cacau

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