Если вы можете настроить iOS 4.0 или выше

Использование GCD, это лучший способ создать синглтон в Objective-C (потокобезопасный)?

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

Это вполне приемлемый и потокобезопасный способ создания экземпляра вашего класса. Технически это не может быть «синглтон» (в том смысле, что когда-либо может быть только 1 из этих объектов), но пока вы используете только [Foo sharedFoo] метод для доступа к объекту, этого достаточно.

instancetype

instancetype это всего лишь одно из многих языковых расширений для Objective-C , с каждым новым выпуском добавляются новые.

Знайте это, любите это.

И возьмите это как пример того, как внимание к деталям низкого уровня может дать вам представление о новых мощных способах преобразования Objective-C.

Смотрите здесь: instancetype

   (instancetype)sharedInstance
{
    static dispatch_once_t once;
    static id sharedInstance;

    dispatch_once(amp;once, ^
    {
        sharedInstance = [self new];
    });    
    return sharedInstance;
}
  

   (Class*)sharedInstance
{
    static dispatch_once_t once;
    static Class *sharedInstance;

    dispatch_once(amp;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(amp;pred, ^{
        shared = [[super alloc] initUniqueInstance];
    });
    return shared;
}

-(instancetype)initUniqueInstance {
    return [super init];
}

@end
  

Вы можете избежать выделения класса с перезаписью метода alloc.

 @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(amp;p, ^{
        useinside = YES;
        _sharedObject = [[MyClass alloc] init];
        useinside = NO;
    });   
    // returns the same object each time
    return _sharedObject;
}
  

Дейв прав, это совершенно нормально. Возможно, вы захотите ознакомиться с документами Apple по созданию синглтона, чтобы получить советы по реализации некоторых других методов, чтобы гарантировать, что когда-либо может быть создан только один, если классы решат НЕ использовать метод sharedFoo.

Если вы хотите убедиться, что [[MyClass alloc] init] возвращает тот же объект, что и sharedInstance (на мой взгляд, это необязательно, но некоторые люди этого хотят), это можно сделать очень легко и безопасно, используя второй dispatch_once:

 - (instancetype)init
{
    static dispatch_once_t once;
    static Class *sharedInstance;

    dispatch_once(amp;once, ^
    {
        // Your normal init code goes here. 
        sharedInstance = self;
    });

    return sharedInstance;
}
  

Это позволяет любой комбинации [[MyClass alloc] init] и [MyClass sharedInstance] возвращать один и тот же объект; [MyClass sharedInstance] было бы просто немного эффективнее. Как это работает: [MyClass sharedInstance] вызовет [[MyClass alloc] init] один раз. Другой код также может вызывать его любое количество раз. Первый вызывающий инициализацию выполнит «обычную» инициализацию и сохранит объект singleton в методе init. Любые последующие вызовы init будут полностью игнорировать то, что вернул alloc, и возвращать тот же sharedInstance; результат alloc будет освобожден.

Метод sharedInstance будет работать так же, как и всегда. Если это не первый вызывающий объект, вызывающий [[MyClass alloc] init], то результат init не является результатом вызова alloc, но это нормально.

Вы спрашиваете, является ли это «лучшим способом создания синглтона».

Несколько мыслей:

1. Во-первых, да, это потокобезопасное решение. Этот dispatch_once шаблон представляет собой современный потокобезопасный способ генерации синглтонов в Objective-C. Здесь не о чем беспокоиться.

2. Однако вы спросили, является ли это «лучшим» способом сделать это. Однако следует признать, что instancetype и [[self alloc] init] потенциально вводят в заблуждение при использовании в сочетании с одиночными элементами.

   Преимущество instancetype заключается в том, что это однозначный способ объявить, что класс может быть подклассом, не прибегая к типу id , как нам приходилось делать в прошлом году.

   Но static в этом методе возникают проблемы с подклассами. Что, если ImageCache и BlobCache синглтоны оба были подклассами из Cache суперкласса без реализации их собственного sharedCache метода?

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

   Чтобы это сработало, вам нужно убедиться, что подклассы реализуют свой собственный sharedInstance (или как бы вы это ни называли для вашего конкретного класса) метод.

   В итоге, ваш оригинал sharedInstance выглядит так, как будто он будет поддерживать подклассы, но это не так. Если вы намерены поддерживать подклассы, по крайней мере, включите документацию, которая предупреждает будущих разработчиков, что они должны переопределить этот метод.

3. Для лучшей совместимости с Swift вы, вероятно, захотите определить это как свойство, а не метод класса, например:

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

   Затем вы можете продолжить и написать средство получения для этого свойства (в реализации будет использоваться dispatch_once предложенный вами шаблон):

      (Foo *)sharedFoo { ... }
     

   Преимущество этого в том, что если пользователь Swift захочет его использовать, он сделает что-то вроде:

    let foo = Foo.shared
     

   Обратите внимание, нет () , потому что мы реализовали его как свойство. Начиная с Swift 3, именно так обычно осуществляется доступ к синглетонам. Таким образом, определение его как свойства помогает облегчить эту совместимость.

   Кстати, если вы посмотрите на то, как Apple определяет свои синглтоны, это шаблон, который они приняли, например, их NSURLSession синглтон определяется следующим образом:

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

4. Другим, очень незначительным соображением, касающимся совместимости Swift, было имя синглтона. Лучше всего, если вы можете включить имя типа, а не sharedInstance . Например, если класс был Foo , вы могли бы определить свойство singleton как sharedFoo . Или, если класс был DatabaseManager , вы могли бы вызвать свойство sharedManager . Тогда пользователи Swift могли бы сделать:

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

   Очевидно, что если вы действительно хотите использовать sharedInstance , вы всегда можете объявить имя Swift, если захотите:

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

   Очевидно, что при написании кода на Objective-C мы не должны позволять совместимости Swift перевешивать другие соображения дизайна, но все же, если мы можем написать код, который изящно поддерживает оба языка, это предпочтительнее.

5. Я согласен с другими, которые указывают, что если вы хотите, чтобы это был настоящий синглтон, в котором разработчики не могут / не должны (случайно) создавать свои собственные экземпляры, unavailable квалификатор на init и new является разумным.

Чтобы создать потокобезопасный синглтон, вы можете сделать вот так:

 @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
  

и в этом блоге очень хорошо объясняются синглтоны в objc / cocoa. синглтоны в objc / cocoa

 @interface className : NSObject{
 (className*)SingleTonShare;
}

@implementation className

 (className*)SingleTonShare{

static className* sharedObj = nil;
static dispatch_once_t once = 0;
dispatch_once(amp;once, ^{

if (sharedObj == nil){
    sharedObj = [[className alloc] init];
}
  });
     return sharedObj;
}
  

 //Create Singleton  
   ( instancetype )defaultDBManager
    {

        static dispatch_once_t onceToken = 0;
        __strong static id _sharedObject = nil;

        dispatch_once(amp;onceToken, ^{
            _sharedObject = [[self alloc] init];
        });

        return _sharedObject;
    }


//In it method
-(instancetype)init
{
    self = [super init];
  if(self)
     {
   //Do your custom initialization
     }
     return self;
}