Як повинен виглядати мій однотонний Objective-C? [зачинено]

Мій метод однодольних аксесуарів, як правило, є деяким варіантом:

static MyClass *gInstance = NULL;

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

    return(gInstance);
}

Що я міг би зробити, щоб покращити це?

Інший варіант - використовувати +(void)initializeметод. З документації:

Час виконання надсилає initializeкожному класу в програмі рівно один раз безпосередньо перед класом або будь-яким класом, який успадковує його, надсилається перше повідомлення з програми. (Таким чином, метод ніколи не може бути застосований, якщо клас не використовується.) Під час виконання програма передає initializeповідомлення класам безпечним способом. Суперкласи отримують це повідомлення перед своїми підкласами.

Тож ви можете зробити щось подібне до цього:

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

[Джерело]

Відповідно до моєї іншої відповіді нижче, я думаю, ви повинні робити:

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

Оскільки Кендалл опублікував безпечний сингл-потік, який намагається уникнути блокування витрат, я подумав, що також підкину:

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

Добре, дозвольте мені пояснити, як це працює:

1. Швидкий випадок: у звичайному виконанні sharedInstanceвже встановлено, тому whileцикл ніколи не виконується і функція повертається після простого тестування на існування змінної;

2. Уповільнений регістр: якщо sharedInstanceйого немає, то примірник виділяється та копіюється в нього за допомогою Порівняння та заміни ("CAS");

3. Змістовий випадок: Якщо обидва потоки намагаються викликати sharedInstanceодночасно І одночасно sharedInstanceне існує, вони обидва ініціалізують нові екземпляри синглтона та намагаються перенести його на позицію CAS. Незалежно від того, хто виграє, CAS повертається негайно, той, хто програє, звільняє екземпляр, який він тільки що виділив, і повертає (тепер встановлений) sharedInstance. Сингл OSAtomicCompareAndSwapPtrBarrierвиступає як бар'єр запису для потоку налаштування, так і бар'єр читання з тестової нитки.

статичний MyClass * sharedInst = нуль;

+ (id) sharedInstance
{
    @synchronize (само) {
        якщо (sharedInst == нуль) {
            / * sharedInst налаштовано в init * /
            [[самоалок] ініт];
        }
    }
    повернути sharedInst;
}

- (ід) ініт
{
    якщо (sharedInst! = нуль) {
        [NSException підвищення: NSInternalInconsistencyException
            формат: @ "[% @% @] не можна викликати; використовуйте + [% @% @] замість"],
            NSStringFromClass ([самоклас]), NSStringFromSelector (_cmd), 
            NSStringFromClass ([самоклас]),
            NSStringFromSelector (@selector (sharedInstance) "];
    } else if (self = [super init]) {
        sharedInst = Я;
        / * Який би клас не був тут * /
    }
    повернути sharedInst;
}

/ * Вони, ймовірно, нічого не роблять
   додаток GC Тримає одиноку
   як фактичний синглтон в a
   не додаток CG
* /
- (NSUInteger) retainCount
{
    повернути NSUIntegerMax;
}

- (oneway void) випуск
{
}

- (ід) зберігати
{
    повернути sharedInst;
}

- (ід) автореліз
{
    повернути sharedInst;
}

Редагувати: Ця реалізація застаріла з ARC. Будь ласка, подивіться, як я можу реалізувати одиночний об'єктив Objective-C, сумісний з ARC? для правильної реалізації.

Усі реалізації ініціалізації, які я читав в інших відповідях, мають загальну помилку.

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

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

Документація Apple рекомендує перевірити тип класу у блоці ініціалізації. Оскільки підкласи викликають ініціалізацію за замовчуванням. Існує неочевидний випадок, коли підкласи можуть створюватися опосередковано через KVO. Бо якщо ви додасте наступний рядок в інший клас:

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

Objective-C неявно створить підклас MySingletonClass, що призведе до другого запуску +initialize.

Ви можете подумати, що вам слід неявно перевірити наявність ініціалізації дублікатів у вашому блоці init:

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

Але ти будеш стріляти собі в ногу; або ще гірше - дати іншому розробникові можливість стріляти собі в ногу.

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

TL; DR, ось моя реалізація

@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 нашим власним макросом твердження; або просто NSAssert.)

Ретельне пояснення макрокоду Singleton знаходиться в блозі Cocoa With Love

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

У мене є цікава версія в sharedInstance, яка безпечна для потоків, але не блокується після ініціалізації. Я ще не достатньо впевнений у цьому, щоб змінити верхню відповідь на запит, але я подаю її для подальшого обговорення:

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

Коротка відповідь: Казкове.

Довга відповідь: Щось на кшталт…

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

Не забудьте прочитати заголовок dispatch / Once.h, щоб зрозуміти, що відбувається. У цьому випадку коментарі до заголовка більше застосовні, ніж сторінки документів або man.

Я переконував синглтон в клас, тому інші класи можуть успадковувати властивості сингтона.

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

Ось приклад якогось класу, який ви хочете стати одиноким.

#import "Singleton.h"

@interface SomeClass : Singleton {

}

@end

@implementation SomeClass 

DEFINE_SHARED_INSTANCE;

@end

Єдине обмеження щодо класу Singleton, це те, що це підклас NSObject. Але більшість часу я використовую одиночні кнопки у своєму коді, вони насправді є підкласами NSObject, тому цей клас дуже полегшує моє життя та робить код чистішим.

Це працює і в не зібраному сміттям середовищі.

@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

Чи не повинен це бути безпечним для ниток і уникати дорогого блокування після першого дзвінка?

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

Ось макрос, який я зібрав:

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

Він заснований на роботі Метта Галлахера. Але зміна впровадження для використання методу шиплячих, як описано тут Дейвом Маклакланом з Google .

Я вітаю коментарі / внески.

Як щодо

static MyClass *gInstance = NULL;

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

    return(gInstance);
}

Так ви уникаєте вартості синхронізації після ініціалізації?

Для поглибленого обговорення однотонної картини в Objective-C дивіться тут:

Використання одинарного шаблону в Objective-C

KLSingleton:

1. Підкласне (до n-го ступеня)
2. ARC сумісний
3. Безпечний з allocіinit
4. Завантажено ліниво
5. Нитка безпечна
6. Без блокування (використовує + ініціалізувати, а не @ синхронізувати)
7. Без макросів
8. Без свисток
9. Простий

KLSingleton

Ви не хочете синхронізувати самостійно ... Оскільки власний об'єкт ще не існує! Ви закінчуєте блокування тимчасового значення id. Ви хочете переконатися, що ніхто інший не може запускати методи класу (sharedInstance, alloc, allocWithZone: тощо), тому вам потрібно синхронізувати об'єкт класу:

@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

Просто хотів залишити це тут, щоб я не втратив цього. Перевага цього полягає в тому, що він може бути використаний в InterfaceBuilder, що є ВЕЛИЧЕЗНОЮ перевагою. Це взято з іншого питання, яке я задав :

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

Я знаю, що є багато коментарів до цього "питання", але я не бачу багатьох людей, які пропонують використовувати макрос для визначення сингтона. Це така загальна закономірність, і макрос значно спрощує синглтон.

Ось макроси, які я написав на основі декількох реалізацій Objc, які я бачив.

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

Приклад використання:

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

Чому макрос інтерфейсу, коли він майже порожній? Узгодженість коду між файлами заголовка та коду; ремонтопридатність, якщо ви хочете додати більше автоматичних методів або змінити їх.

Я використовую метод ініціалізації, щоб створити синглтон, який використовується в найпопулярнішій відповіді тут (під час написання).

За допомогою методів класу Objective C ми можемо просто уникати використання однотонного шаблону звичайним способом:

[[Librarian sharedInstance] openLibrary]

до:

[Librarian openLibrary]

загортаючи клас у інший клас, який просто має Методи класів , таким чином, немає шансів випадково створити повторювані екземпляри, оскільки ми не створюємо жодного екземпляра!

Більш детальний блог я написав тут :)

Щоб продовжити приклад від @ 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;
}

Мій шлях такий простий:

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

Якщо синхронізація вже ініціалізована, блок LOCK не буде введено. Друга перевірка, якщо (! Ініціалізовано), щоб переконатися, що вона ще не ініціалізована, коли поточний потік набуває ЗАМОКУ.

Я не прочитав усі рішення, тож пробачте, якщо цей код є зайвим.

На мою думку, це найбільш безпечна реалізація.

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

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

    return sharedResourcesObj;
}

Зазвичай я використовую код, приблизно такий, як у відповіді Бен Гофштейн (який я також вийшов із Вікіпедії). Я використовую це з причин, які висловив Кріс Гансон у своєму коментарі.

Однак іноді в мене виникає необхідність помістити одиночку в NIB, і в такому випадку я використовую наступне:

@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

Я залишаю реалізацію -retain(тощо) читачеві, хоча вищезгаданий код - це все, що вам потрібно в середовищі, що збирається зі сміттям.

Прийнята відповідь, хоча і складається, невірна.

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

За документацію Apple:

... Ви можете скористатися аналогічним підходом до синхронізації методів класу асоційованого класу, використовуючи об'єкт Class замість self.

Навіть якщо використання самостійної роботи не повинно, і це виглядає як помилка копіювання та вставки для мене. Правильною реалізацією для фабричного методу класу буде:

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