Objective-C singletonum nasıl olmalı? [kapalı]

Singleton erişimci yöntemim genellikle aşağıdakilerin bir çeşididir:

static MyClass *gInstance = NULL;

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

    return(gInstance);
}

Bunu geliştirmek için ne yapabilirim?

Başka bir seçenek de +(void)initializeyöntemi kullanmaktır . Belgelerden:

Çalışma zamanı initialize, bir programdaki her sınıfa, sınıftan tam olarak bir kez önce veya ondan devralan herhangi bir sınıfa ilk iletisini programın içinden gönderir. (Bu nedenle, sınıf kullanılmazsa yöntem asla çağrılmayabilir.) Çalışma zamanı, initializeiletiyi sınıflara iş parçacığı için güvenli bir şekilde gönderir . Üst sınıflar bu mesajı alt sınıflarından önce alır.

Böylece buna benzer bir şey yapabilirsiniz:

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

[Kaynak]

Aşağıdaki diğer cevabım uyarınca, bence yapmalısınız:

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

Yana Kendall yayınlanmıştır maliyetleri kilitleme önlemek için girişimlerde tekil bir evre, ben de bir tane atmak düşündü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;                                                                        
}

Tamam, bunun nasıl çalıştığını açıklayayım:

1. Hızlı durum: Normal yürütmede sharedInstanceönceden ayarlanmış olduğundan, whiledöngü asla yürütülmez ve değişkenin varlığını test ettikten sonra işlev geri döner;

2. Yavaş durumda: sharedInstanceYoksa, bir Karşılaştırma ve Değiştirme ('CAS') kullanarak bir örnek atanır ve bu örneğe kopyalanır;

3. Koşullu durum: İki iş parçacığı sharedInstanceaynı anda aramaya çalışırsa VE aynı anda sharedInstancemevcut değilse, hem singletonun yeni örneklerini başlatır hem de onu CAS konumuna getirmeye çalışır. Hangisi kazanırsa CAS derhal geri döner, hangisi kaybederse az önce tahsis ettiği örneği serbest bırakır ve (şimdi ayarlanmış) döndürür sharedInstance. Tekil OSAtomicCompareAndSwapPtrBarrier, hem ayar dişi için bir yazma bariyeri hem de test dişinden bir okuma bariyeri gibi davranır.

statik Sınıfım * sharedInst = nil;

+ (id) sharedInstance
{
    @synchronize (self) {
        if (sharedInst == nil) {
            / * sharedInit'te kuruluyor * /
            [[kendi kendine ayrılmış] init];
        }
    }
    dönüş paylaştıInst;
}

- (id) init
{
    if (sharedInst! = nil) {
        [NSException artışı: NSInternalInconsistencyException
            format: @ "[% @% @] çağrılamaz; bunun yerine + [% @% @] kullanın"],
            NSStringFromClass ([kendi sınıfı]), NSStringFromSelector (_cmd), 
            NSStringFromClass ([kendi sınıfı]),
            NSStringFromSelector (@selector (sharedInstance) "];
    } else if (self = [süper başlangıç]) {
        sharedInst = benlik;
        / * Burada hangi sınıfa özel olursa olsun * /
    }
    dönüş paylaştıInst;
}

/ * Bunlar muhtemelen
   bir GC uygulaması. Singleton'u korur
   gerçek bir singleton olarak
   CG olmayan uygulama
* /
- (NSUInteger) retainCount
{
    dönüş NSUIntegerMax;
}

- (yoldan çıkma) serbest bırakma
{
}

- (kimlik) alıkoyma
{
    dönüş paylaştıInst;
}

- (kimlik) otomatik yayın
{
    dönüş paylaştıInst;
}

Düzenleme: Bu uygulama ARC ile eski. Lütfen bir göz atın ARC ile uyumlu bir Objective-C singletonunu nasıl uygularım? doğru uygulama için.

Diğer cevaplarda okuduğum başlatmanın tüm uygulamaları ortak bir hatayı paylaşır.

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

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

Apple belgeleri, başlatma bloğunuzdaki sınıf türünü kontrol etmenizi önerir. Çünkü alt sınıflar varsayılan olarak başlatmayı çağırır. Alt sınıfların dolaylı olarak KVO aracılığıyla oluşturulabileceği açık olmayan bir durum vardır. Başka bir sınıfa aşağıdaki satırı eklerseniz:

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

Objective-C dolaylı olarak MySingletonClass alt sınıfını oluşturacak ve bunun ikinci bir tetiklenmesine neden olacaktır +initialize.

İnit bloğunuzda yinelenen başlatmayı dolaylı olarak kontrol etmeniz gerektiğini düşünebilirsiniz:

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

Ama kendini ayağından vuracaksın; ya da daha kötüsü, başka bir geliştiriciye kendilerini ayağa vurma fırsatı verin.

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

TL; DR, işte benim uygulamam

@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

(ZAssert'i kendi iddia makamımızla değiştirin veya yalnızca NSAssert'i kullanın.)

Singleton makro kodunun kapsamlı bir açıklaması blogda Kakaolu Aşk

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

Ben iş parçacığı güvenli, ancak başlatma sonra kilit değil sharedInstance ilginç bir varyasyonu var. Henüz üst cevabı istendiği gibi değiştirecek kadar emin değilim, ancak daha fazla tartışma için sunuyorum:

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

Kısa cevap: Muhteşem.

Uzun cevap: Gibi bir şey ....

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

Neler olduğunu anlamak için / once.h başlıklarını okuduğunuzdan emin olun . Bu durumda başlık yorumları dokümanlar veya kılavuz sayfasından daha uygulanabilir.

Singleton'u bir sınıfa yuvarladım, böylece diğer sınıflar singleton özelliklerini devralabilir.

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

Ve burada tekil olmak istediğiniz bir sınıf örneği var.

#import "Singleton.h"

@interface SomeClass : Singleton {

}

@end

@implementation SomeClass 

DEFINE_SHARED_INSTANCE;

@end

Singleton sınıfıyla ilgili tek sınırlama, NSObject alt sınıfı olmasıdır. Ama çoğu zaman benim kodda singletons kullanın aslında NSObject alt sınıfları, bu yüzden bu sınıf gerçekten hayatımı kolaylaştırmak ve kod temiz yapmak.

Bu, çöp toplanmamış bir ortamda da çalışır.

@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

Bu güvenli değil ve ilk aramadan sonra pahalı kilitlemeden kaçınmalı mıydı?

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

İşte bir araya getirdiğim bir makro :

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

Bu, Matt Gallagher tarafından yapılan çalışmalara dayanıyor. Ancak , burada Google'dan Dave MacLachlan tarafından açıklanan yöntem dolandırıcılığını kullanmak için uygulamayı değiştiriyor .

Yorumları / katkıları memnuniyetle karşılıyoruz.

Peki ya

static MyClass *gInstance = NULL;

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

    return(gInstance);
}

Peki başlatmadan sonra senkronizasyon maliyetinden kaçınıyor musunuz?

Objective-C'deki singleton modelinin derinlemesine tartışılması için buraya bakın:

Tek Amaçlı Deseni Objective-C'de Kullanma

KLSingleton:

1. Alt sınıflanabilir (n. Dereceye kadar)
2. ARC uyumlu
3. İle güvenli allocveinit
4. Tembel olarak yüklendi
5. Konu güvenli
6. Kilitsiz (@synchronize değil + başlat, kullanır)
7. Makro-free
8. Swizzle içermeyen
9. Basit

KLSingleton

Kendini senkronize etmek istemiyorsun ... Kendinden nesne henüz mevcut olmadığından! Sonunda geçici bir kimlik değerine kilitlenirsiniz. Başka hiç kimsenin sınıf yöntemlerini (sharedInstance, ayırma, investWithZone: vb.) Çalıştıramayacağından emin olmak istersiniz, bu nedenle bunun yerine sınıf nesnesini senkronize etmeniz gerekir:

@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

Bunu burada bırakmak istedim, bu yüzden kaybetmem. Bunun avantajı, BÜYÜK bir avantaj olan InterfaceBuilder'da kullanılabilir olmasıdır. Bu, sorduğum başka bir sorudan alındı :

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

Bu "soru" hakkında çok fazla yorum olduğunu biliyorum, ama pek çok insan singleton tanımlamak için bir makro kullanmayı öneren görmüyorum. Bu yaygın bir model ve bir makro singletonu büyük ölçüde basitleştiriyor.

İşte gördüğüm birkaç Objc uygulamasına dayanarak yazdığım makrolar.

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

Kullanım örneği:

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

Neredeyse boş olduğunda neden bir arayüz makrosu? Üstbilgi ve kod dosyaları arasındaki kod tutarlılığı; daha fazla otomatik yöntem eklemek veya bu yöntemi değiştirmek isterseniz

Burada en popüler cevap kullanılan (yazma sırasında) singleton oluşturmak için initialize yöntemini kullanıyorum.

Objective C sınıfı yöntemleri ile, sadece singleton desenini olağan şekilde kullanmaktan kaçınabiliriz:

[[Librarian sharedInstance] openLibrary]

için:

[Librarian openLibrary]

Sınıfı yalnızca Sınıf Yöntemleri olan başka bir sınıfın içine sararak , hiçbir şekilde örnek oluşturmadığımız için yanlışlıkla yinelenen örnekler oluşturma şansımız olmaz!

Burada daha ayrıntılı bir blog yazdım :)

@ Robbie-hanson'dan örneği genişletmek için ...

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

Yolum şöyle basit:

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

Singleton zaten başlatılmışsa, LOCK bloğu girilmez. İkinci kontrol (! Başlatılmış), mevcut iş parçacığı KİLİT aldığında henüz başlatılmadığından emin olmak içindir.

Ben tüm çözümleri okumadım, bu kod gereksiz ise affet.

Bu benim görüşüme göre en güvenli iş parçacığı uygulamasıdır.

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

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

    return sharedResourcesObj;
}

Genellikle Ben Hoffstein'ın cevabındakine benzer bir kod kullanıyorum (ki bu da Wikipedia'dan çıktım). Chris Hanson'un yorumunda belirtilen nedenlerden dolayı kullanıyorum.

Ancak, bazen bir NIB içine bir singleton koymaya ihtiyacım var ve bu durumda aşağıdakileri kullanıyorum:

@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

-retainYukarıdaki kod çöp toplanmış bir ortamda ihtiyacınız olsa da, (vb.) Uygulamasını okuyucuya bırakıyorum .

Kabul edilen cevap, derlenmesine rağmen yanlıştır.

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

Apple belgelerine göre:

... Benzer bir yaklaşımı self yerine Class nesnesini kullanarak ilişkili sınıfın sınıf yöntemlerini senkronize etmek için kullanabilirsiniz.

Kendi kendine çalışıyor olsa bile, olmamalı ve bu bana bir kopyala yapıştır hatası gibi görünüyor. Bir sınıf fabrikası yöntemi için doğru uygulama:

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