Como deve ser meu singleton Objective-C? [fechadas]

Meu método acessador singleton geralmente é uma variante de:

static MyClass *gInstance = NULL;

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

    return(gInstance);
}

O que eu poderia estar fazendo para melhorar isso?

Outra opção é usar o +(void)initializemétodo A partir da documentação:

O tempo de execução envia initializepara cada classe em um programa exatamente uma vez antes da classe, ou qualquer classe que herda dela, recebe sua primeira mensagem de dentro do programa. (Portanto, o método nunca pode ser chamado se a classe não for usada.) O tempo de execução envia a initializemensagem para as classes de maneira segura para threads. As superclasses recebem essa mensagem antes de suas subclasses.

Então você pode fazer algo parecido com isso:

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

[Fonte]

Pela minha outra resposta abaixo, acho que você deveria estar fazendo:

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

Como Kendall postou um singleton thread-safe que tenta evitar custos de bloqueio, pensei em lançar um também:

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

Ok, deixe-me explicar como isso funciona:

1. Caso rápido: na execução normal sharedInstancejá foi definida, o whileloop nunca é executado e a função retorna após simplesmente testar a existência da variável;

2. Caso lento: se sharedInstancenão existir, uma instância é alocada e copiada para ela usando um Compare And Swap ('CAS');

3. Caso contencioso: se dois encadeamentos tentarem chamar sharedInstanceao mesmo tempo E sharedInstance não existirem ao mesmo tempo, inicializarão novas instâncias do singleton e tentarão colocá-lo na posição CAS. Qualquer que seja o ganhador, o CAS retornará imediatamente, o que perder, libera a instância que acabou de alocar e retorna o (agora definido) sharedInstance. O single OSAtomicCompareAndSwapPtrBarrieratua como uma barreira de gravação para o encadeamento de configuração e uma barreira de leitura do encadeamento de teste.

MyClass estático * sharedInst = nil;

+ (id) sharedInstance
{
    @synchronize (self) {
        if (sharedInst == nil) {
            / * sharedInst configurado no init * /
            [[auto-alocação] init];
        }
    }
    return sharedInst;
}

- (id) init
{
    if (sharedInst! = nil) {
        [Aumento de NSException: NSInternalInconsistencyException
            formato: @ "[% @% @] não pode ser chamado; use + [% @% @]]",
            NSStringFromClass ([classe própria]), NSStringFromSelector (_cmd), 
            NSStringFromClass ([auto-classe]),
            NSStringFromSelector (@selector (sharedInstance) "];
    } else if (self = [super init]) {
        sharedInst = self;
        / * Qualquer classe específica aqui * /
    }
    return sharedInst;
}

/ * Provavelmente não fazem nada
   um aplicativo de GC. Mantém singleton
   como um singleton real em um
   aplicativo não CG
* /
- (NSUInteger) reterContagem
{
    return NSUIntegerMax;
}

- liberação (vazia)
{
}

- (id) reter
{
    return sharedInst;
}

- (id) autorelease
{
    return sharedInst;
}

Edit: Esta implementação obsoleta com o ARC. Veja como implementar um singleton Objective-C que seja compatível com o ARC? para implementação correta.

Todas as implementações de inicialização que eu li em outras respostas compartilham um erro comum.

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

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

A documentação da Apple recomenda que você verifique o tipo de classe no seu bloco de inicialização. Porque as subclasses chamam a inicialização por padrão. Existe um caso não óbvio em que subclasses podem ser criadas indiretamente através do KVO. Pois se você adicionar a seguinte linha em outra classe:

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

O Objective-C criará implicitamente uma subclasse de MySingletonClass, resultando em um segundo disparo de +initialize.

Você pode pensar que deve verificar implicitamente a inicialização duplicada no seu bloco init, como tal:

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

Mas você vai dar um tiro no próprio pé; ou pior, dê a outro desenvolvedor a oportunidade de dar um tiro no próprio pé.

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

TL; DR, aqui está minha implementação

@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

(Substitua o ZAssert por nossa própria macro de asserção; ou apenas NSAssert.)

Uma explicação completa do código da macro Singleton está no blog Cocoa With Love

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

Eu tenho uma variação interessante no sharedInstance que é seguro para threads, mas não é bloqueado após a inicialização. Ainda não tenho certeza o suficiente para modificar a resposta principal, conforme solicitado, mas apresento para discussão adicional:

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

Resposta curta: Fabuloso.

Resposta longa: Algo como ....

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

Leia o cabeçalho dispatch / once.h para entender o que está acontecendo. Nesse caso, os comentários do cabeçalho são mais aplicáveis ​​que os documentos ou a página de manual.

Eu rolei singleton em uma classe, para que outras classes possam herdar propriedades singleton.

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

E aqui está um exemplo de alguma classe, na qual você deseja se tornar único.

#import "Singleton.h"

@interface SomeClass : Singleton {

}

@end

@implementation SomeClass 

DEFINE_SHARED_INSTANCE;

@end

A única limitação sobre a classe Singleton é que ela é a subclasse NSObject. Mas na maioria das vezes eu uso singletons no meu código, eles são de fato subclasses NSObject, então essa classe realmente facilita minha vida e torna o código mais limpo.

Isso funciona em um ambiente sem coleta de lixo também.

@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

Isso não deve ser seguro e evitar o bloqueio caro após a primeira chamada?

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

Aqui está uma macro que eu montei:

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

Ele é baseado no trabalho aqui de Matt Gallagher. Mas, alterando a implementação para usar o método swizzling, descrito aqui por Dave MacLachlan, do Google .

Congratulo-me com comentários / contribuições.

E se

static MyClass *gInstance = NULL;

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

    return(gInstance);
}

Então você evita o custo da sincronização após a inicialização?

Para uma discussão aprofundada do padrão singleton no Objective-C, veja aqui:

Usando o padrão Singleton em Objective-C

KLSingleton é:

1. Subclassível (até o n-ésimo grau)
2. Compatível com ARC
3. Seguro com alloceinit
4. Carregado preguiçosamente
5. Discussão segura
6. Sem bloqueio (usa + inicializar, não @ sincronizar)
7. Sem macro
8. Sem Swizzle
9. Simples

KLSingleton

Você não deseja sincronizar consigo mesmo ... Como o objeto próprio ainda não existe! Você acaba bloqueando um valor de ID temporário. Você deseja garantir que ninguém mais possa executar métodos de classe (sharedInstance, aloc, alocWithZone :, etc), portanto, é necessário sincronizar no objeto de classe:

@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

Só queria deixar isso aqui para não perder. A vantagem deste é que ele é utilizável no InterfaceBuilder, que é uma enorme vantagem. Isso é retirado de outra pergunta que eu fiz :

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

Sei que existem muitos comentários sobre essa "pergunta", mas não vejo muitas pessoas sugerindo o uso de uma macro para definir o singleton. É um padrão tão comum e uma macro simplifica bastante o singleton.

Aqui estão as macros que escrevi com base nas várias implementações de Objc que eu já vi.

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

Exemplo de uso:

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

Por que uma macro de interface quando está quase vazia? Consistência do código entre os arquivos de cabeçalho e código; manutenção caso você queira adicionar métodos mais automáticos ou alterá-los.

Estou usando o método initialize para criar o singleton, como é usado na resposta mais popular aqui (no momento da redação).

Com os métodos da classe Objective C, podemos evitar o uso do padrão singleton da maneira usual, a partir de:

[[Librarian sharedInstance] openLibrary]

para:

[Librarian openLibrary]

envolvendo a classe dentro de outra classe que apenas possui métodos de classe , para que não haja chance de criar instâncias duplicadas acidentalmente, pois não estamos criando nenhuma instância!

Eu escrevi um blog mais detalhado aqui :)

Para estender o exemplo de @ robbie-hanson ...

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

Meu jeito é simples assim:

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

Se o singleton já estiver inicializado, o bloco LOCK não será inserido. A segunda verificação se (! Inicializado) é para garantir que ainda não esteja inicializado quando o encadeamento atual adquire o LOCK.

Eu não li todas as soluções, então perdoe se esse código é redundante.

Esta é a implementação mais segura de threads na minha opinião.

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

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

    return sharedResourcesObj;
}

Eu costumo usar código semelhante ao da resposta de Ben Hoffstein (que também saí da Wikipedia). Eu o uso pelas razões declaradas por Chris Hanson em seu comentário.

No entanto, às vezes tenho a necessidade de colocar um singleton em um NIB e, nesse caso, uso o seguinte:

@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

Deixo a implementação de -retain(etc.) para o leitor, embora o código acima seja tudo o que você precisa em um ambiente de coleta de lixo.

A resposta aceita, embora seja compilada, está incorreta.

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

De acordo com a documentação da Apple:

... Você pode adotar uma abordagem semelhante para sincronizar os métodos de classe da classe associada, usando o objeto Class em vez de self.

Mesmo se usar auto-obras, não deveria e isso parece um erro de copiar e colar para mim. A implementação correta para um método de fábrica de classe seria:

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