Jika Anda dapat menargetkan iOS 4.0 atau lebih tinggi

Menggunakan GCD, apakah ini cara terbaik untuk membuat singleton di Objective-C (thread safe)?

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

Ini adalah cara yang bisa diterima dan aman untuk membuat instance kelas Anda. Secara teknis mungkin bukan "singleton" (dalam hal itu hanya ada 1 objek), tetapi selama Anda hanya menggunakan [Foo sharedFoo]metode untuk mengakses objek, ini cukup baik.

jenis instancet

instancetypehanyalah salah satu dari banyak ekstensi bahasa Objective-C, dengan lebih banyak ditambahkan dengan setiap rilis baru.

Ketahuilah, menyukainya.

Dan anggap sebagai contoh bagaimana memperhatikan detail tingkat rendah dapat memberi Anda wawasan tentang cara-cara baru yang kuat untuk mengubah Objective-C.

Rujuk di sini: tipe instancet

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

Anda dapat menghindari bahwa kelas dialokasikan dengan menimpa metode alokasi.

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

Dave benar, itu baik-baik saja. Anda mungkin ingin memeriksa dokumen Apple tentang cara membuat singleton untuk kiat menerapkan beberapa metode lain untuk memastikan bahwa hanya satu yang dapat dibuat jika kelas memilih TIDAK untuk menggunakan metode sharedFoo.

Jika Anda ingin memastikan bahwa [[alokasi MyClass] init] mengembalikan objek yang sama dengan sharedInstance (tidak diperlukan menurut pendapat saya, tetapi beberapa orang menginginkannya), itu dapat dilakukan dengan sangat mudah dan aman menggunakan dispatch_once kedua:

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

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

    return sharedInstance;
}

Ini memungkinkan setiap kombinasi [[alokasi MyClass] init] dan [MyClass sharedInstance] untuk mengembalikan objek yang sama; [MyClass sharedInstance] hanya akan sedikit lebih efisien. Cara kerjanya: [MyClass sharedInstance] akan memanggil [[alokasi MyClass] init] sekali. Kode lain bisa memanggilnya juga, berapa kali. Penelepon pertama ke init akan melakukan inisialisasi "normal" dan menyimpan objek tunggal dalam metode init. Setiap panggilan selanjutnya ke init akan sepenuhnya mengabaikan alokasi apa yang dikembalikan dan mengembalikan Instansi yang sama; hasil alokasi akan dibatalkan alokasi.

Metode + sharedInstance akan berfungsi seperti biasa. Jika itu bukan penelepon pertama yang memanggil [[alokasi MyClass] init], maka hasil dari init bukanlah hasil dari panggilan alokasi, tetapi itu OK.

Anda bertanya apakah ini "cara terbaik untuk membuat singleton".

Beberapa pemikiran:

1. Pertama, ya, ini adalah solusi yang aman. dispatch_oncePola ini adalah cara modern yang aman untuk menghasilkan lajang di Objective-C. Jangan khawatir di sana.

2. Namun Anda bertanya, apakah ini cara "terbaik" untuk melakukannya. Orang harus mengakui, bahwa, instancetypedan [[self alloc] init]berpotensi menyesatkan ketika digunakan bersama dengan lajang.

   Keuntungannya instancetypeadalah bahwa ini adalah cara yang tidak ambigu untuk menyatakan bahwa kelas dapat subkelas tanpa menggunakan jenis id, seperti yang harus kita lakukan di masa lalu.

   Tetapi staticdalam metode ini menyajikan tantangan subclassing. Bagaimana jika ImageCachedan BlobCachelajang keduanya subclass dari Cachesuperclass tanpa menerapkan sharedCachemetode mereka sendiri ?

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

   Agar ini berfungsi, Anda harus memastikan subclass mengimplementasikan sharedInstancemetode mereka sendiri (atau apa pun namanya untuk kelas Anda).

   Intinya, sumber asli Anda sharedInstance sepertinya akan mendukung subclass, tetapi tidak. Jika Anda bermaksud mendukung subclassing, paling tidak sertakan dokumentasi yang memperingatkan pengembang masa depan bahwa mereka harus mengganti metode ini.

3. Untuk interoperabilitas terbaik dengan Swift, Anda mungkin ingin mendefinisikan ini sebagai properti, bukan metode kelas, misalnya:

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

   Kemudian Anda dapat melanjutkan dan menulis getter untuk properti ini (implementasinya akan menggunakan dispatch_oncepola yang Anda sarankan):

   + (Foo *)sharedFoo { ... }

   Manfaatnya adalah jika pengguna Swift menggunakannya, mereka akan melakukan sesuatu seperti:

   let foo = Foo.shared

   Catatan, tidak ada (), karena kami menerapkannya sebagai properti. Mulai Swift 3, beginilah cara lajang umumnya diakses. Jadi mendefinisikannya sebagai properti membantu memfasilitasi interoperabilitas itu.

   Sebagai tambahan, jika Anda melihat bagaimana Apple mendefinisikan lajang mereka, ini adalah pola yang telah mereka adopsi, misalnya NSURLSessionlajang mereka didefinisikan sebagai berikut:

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

4. Pertimbangan interoperabilitas Swift yang sangat kecil adalah nama singleton. Lebih baik jika Anda dapat memasukkan nama tipe, daripada sharedInstance. Misalnya, jika kelasnya adalah Foo, Anda mungkin mendefinisikan properti singleton sebagai sharedFoo. Atau jika kelasnya adalah DatabaseManager, Anda dapat menghubungi properti sharedManager. Kemudian pengguna Swift dapat melakukan:

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

   Jelas, jika Anda benar-benar ingin menggunakan sharedInstance, Anda selalu dapat mendeklarasikan nama Swift jika Anda ingin:

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

   Jelas, ketika menulis kode Objective-C, kita seharusnya tidak membiarkan interoperabilitas Swift lebih besar daripada pertimbangan desain lainnya, tetapi tetap saja, jika kita dapat menulis kode yang dengan anggun mendukung kedua bahasa, itu lebih disukai.

5. Saya setuju dengan orang lain yang menunjukkan bahwa jika Anda ingin ini menjadi singleton sejati di mana pengembang tidak dapat / tidak seharusnya (secara tidak sengaja) membuat instantiate instance mereka sendiri, unavailablekualifikasi initdan newbijaksana.

Untuk membuat thread safe singleton, Anda dapat melakukannya seperti ini:

@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

dan blog ini menjelaskan singleton dengan sangat baik di objc / cocoa

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