Якщо ви можете націлити на iOS 4.0 або вище

Використовуючи GCD, це найкращий спосіб створити синглтон в Objective-C (безпека потоку)?

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

Це цілком прийнятний і безпечний для потоків спосіб створити екземпляр свого класу. Технічно це не може бути "одиночним" (оскільки в ньому може бути лише 1 з цих об'єктів), але поки ви використовуєте лише [Foo sharedFoo]метод для доступу до об'єкта, це досить добре.

екземпляр

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

Знай це, люби його.

І візьмемо це як приклад того, як звернення уваги на деталі низького рівня може дати вам уявлення про нові потужні способи перетворення Objective-C.

Посилайтесь тут: typetype

+ (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

Ви можете уникнути, що клас буде виділено з перезаписом методу 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(&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(&once, ^
    {
        // Your normal init code goes here. 
        sharedInstance = self;
    });

    return sharedInstance;
}

Це дозволяє будь-якій комбінації [[MyClass alloc] init] та [MyClass sharedInstance] повернути один і той же об'єкт; [MyClass sharedInstance] буде просто трохи ефективнішим. Як це працює: [MyClass sharedInstance] один раз зателефонує [[MyClass alloc] init]. Інший код може також називати його, будь-яку кількість разів. Перший виклик, який викликає init, зробить "звичайну" ініціалізацію та збереже єдиний об'єкт у методі init. Будь-які пізніші виклики до init повністю ігнорують те, що аллок повернувся та поверне той самий sharedInstance; результат алокації буде розміщений.

Метод + 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

   Тоді ви можете продовжити і написати Getter для цієї властивості (реалізація використовуватиме 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 / какао

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