Seperti apa bentuk singleton Objective-C saya? [Tutup]

Metode pengakses singleton saya biasanya beberapa varian:

static MyClass *gInstance = NULL;

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

    return(gInstance);
}

Apa yang bisa saya lakukan untuk memperbaiki ini?

Pilihan lain adalah menggunakan +(void)initializemetode ini. Dari dokumentasi:

Runtime mengirimkan initializeke setiap kelas dalam suatu program tepat satu kali tepat sebelum kelas, atau kelas apa pun yang mewarisi darinya, dikirim pesan pertama dari dalam program. (Dengan demikian metode ini mungkin tidak pernah dipanggil jika kelas tidak digunakan.) Runtime mengirimkan initializepesan ke kelas dengan cara yang aman. Superclasses menerima pesan ini sebelum subclass mereka.

Jadi Anda bisa melakukan sesuatu yang mirip dengan ini:

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

[Sumber]

Per jawaban saya yang lain di bawah ini, saya pikir Anda harus melakukan:

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

Karena Kendall memposting threadsafe singleton yang berusaha untuk menghindari biaya penguncian, saya pikir saya akan melemparkannya juga:

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

Oke, izinkan saya menjelaskan cara kerjanya:

1. Kasus cepat: Dalam eksekusi normal sharedInstancetelah ditetapkan, sehingga whileloop tidak pernah dieksekusi dan fungsi kembali setelah hanya menguji keberadaan variabel;

2. Kasing lambat: Jika sharedInstancetidak ada, maka sebuah instance dialokasikan dan disalin ke dalamnya menggunakan Compare And Swap ('CAS');

3. Contended case: Jika dua utas keduanya mencoba menelepon sharedInstancepada waktu yang sama DAN sharedInstance tidak ada pada saat yang sama, maka keduanya akan menginisialisasi instance baru dari singleton dan mencoba untuk CAS ke posisi. Yang mana saja yang memenangkan CAS, segera kembali, yang mana yang kalah akan melepaskan instance yang baru saja dialokasikan dan mengembalikan (yang sudah ditetapkan) sharedInstance. Single ini OSAtomicCompareAndSwapPtrBarrierbertindak sebagai penghalang tulis untuk utas pengaturan dan pembatas baca dari utas pengujian.

static MyClass * sharedInst = nil;

+ (id) BerbagiInstance
{
    @sinkronkan (mandiri) {
        if (sharedInst == nil) {
            / * sharedInst diatur di init * /
            [[alokasi mandiri] init];
        }
    }
    return sharedInst;
}

- (id) init
{
    if (sharedInst! = nil) {
        [NSException kenaikan: NSInternalInconsistencyException
            format: @ "[% @% @] tidak dapat dipanggil; gunakan + [% @% @] sebagai gantinya"],
            NSStringFromClass ([kelas mandiri]), NSStringFromSelector (_cmd), 
            NSStringFromClass ([kelas mandiri]),
            NSStringFromSelector (@selector (sharedInstance) "];
    } lain jika (self = [super init]) {
        sharedInst = diri;
        / * Apapun kelas khusus di sini * /
    }
    return sharedInst;
}

/ * Ini mungkin tidak ada artinya
   aplikasi GC. Menyimpan singleton
   sebagai singleton aktual dalam sebuah
   aplikasi non CG
* /
- (NSUInteger) retainCount
{
    mengembalikan NSUIntegerMax;
}

- Pelepasan (oneway void)
{
}

- (id) simpan
{
    return sharedInst;
}

- (id) autorelease
{
    return sharedInst;
}

Sunting: Implementasi ini usang dengan ARC. Silakan lihat Bagaimana cara mengimplementasikan singleton Objective-C yang kompatibel dengan ARC? untuk implementasi yang benar.

Semua implementasi inisialisasi yang saya baca di jawaban lain berbagi kesalahan umum.

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

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

Dokumentasi Apple merekomendasikan Anda memeriksa jenis kelas di blok inisialisasi Anda. Karena subclass memanggil inisialisasi secara default. Ada kasus yang tidak jelas di mana subclass dapat dibuat secara tidak langsung melalui KVO. Karena jika Anda menambahkan baris berikut di kelas lain:

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

Objective-C secara implisit akan membuat subkelas MySingletonClass yang menghasilkan pemicu kedua +initialize.

Anda mungkin berpikir bahwa Anda harus secara implisit memeriksa inisialisasi duplikat di blok init Anda seperti itu:

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

Tapi Anda akan menembak diri sendiri di kaki; atau lebih buruk memberi pengembang lain kesempatan untuk menembak diri mereka sendiri.

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

TL; DR, ini implementasi saya

@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

(Ganti ZAssert dengan makro pernyataan kami sendiri; atau hanya NSAssert.)

Penjelasan menyeluruh tentang kode makro Singleton ada di blog Cocoa With Love

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

Saya memiliki variasi yang menarik tentang sharedInstance yang aman, tetapi tidak mengunci setelah inisialisasi. Saya belum cukup yakin untuk memodifikasi jawaban atas seperti yang diminta, tetapi saya menyajikannya untuk diskusi lebih lanjut:

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

Jawaban singkat: Luar biasa.

Jawaban panjang: Sesuatu seperti ....

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

Pastikan untuk membaca tajuk pengiriman / once.h untuk memahami apa yang terjadi. Dalam hal ini komentar header lebih berlaku daripada halaman dokumen atau manual.

Saya telah memasukkan singleton ke dalam sebuah kelas, sehingga kelas-kelas lain dapat mewarisi sifat-sifat singleton.

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

Dan di sini adalah contoh dari beberapa kelas, bahwa Anda ingin menjadi singleton.

#import "Singleton.h"

@interface SomeClass : Singleton {

}

@end

@implementation SomeClass 

DEFINE_SHARED_INSTANCE;

@end

Satu-satunya batasan tentang kelas Singleton, adalah bahwa itu adalah subclass NSObject. Tetapi sebagian besar waktu saya menggunakan lajang dalam kode saya mereka sebenarnya subclass NSObject, sehingga kelas ini benar-benar memudahkan hidup saya dan membuat kode lebih bersih.

Ini juga berfungsi di lingkungan yang dikumpulkan tanpa sampah.

@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

Tidakkah ini akan menjadi threadsafe dan menghindari penguncian yang mahal setelah panggilan pertama?

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

Berikut ini makro yang saya kumpulkan:

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

Ini didasarkan pada pekerjaan di sini oleh Matt Gallagher Tetapi mengubah implementasi untuk menggunakan metode swizzling seperti dijelaskan di sini oleh Dave MacLachlan dari Google .

Saya menyambut komentar / kontribusi.

Bagaimana tentang

static MyClass *gInstance = NULL;

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

    return(gInstance);
}

Jadi Anda menghindari biaya sinkronisasi setelah inisialisasi?

Untuk diskusi mendalam tentang pola tunggal di Objective-C, lihat di sini:

Menggunakan Pola Singleton di Objective-C

KLSingleton adalah:

1. Subclassible (ke tingkat ke-n)
2. Kompatibel dengan ARC
3. Aman dengan allocdaninit
4. Dimuat dengan malas
5. Aman untuk benang
6. Bebas kunci (menggunakan + inisialisasi, bukan @sinkronkan)
7. Bebas makro
8. Bebas dari swizzle
9. Sederhana

KLSingleton

Anda tidak ingin menyinkronkan diri ... Karena objek diri belum ada! Anda akhirnya mengunci nilai id sementara. Anda ingin memastikan bahwa tidak ada orang lain yang dapat menjalankan metode kelas (sharedInstance, alokasi, alokasiWithZone :, dll), jadi Anda perlu menyinkronkan objek kelas:

@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

Hanya ingin meninggalkan ini di sini jadi saya tidak kehilangan itu. Keuntungan yang satu ini adalah dapat digunakan di InterfaceBuilder, yang merupakan keuntungan BESAR. Ini diambil dari pertanyaan lain yang saya ajukan :

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

Saya tahu ada banyak komentar tentang "pertanyaan" ini, tetapi saya tidak melihat banyak orang menyarankan menggunakan makro untuk mendefinisikan singleton. Ini adalah pola umum dan makro sangat menyederhanakan singleton.

Berikut adalah makro yang saya tulis berdasarkan beberapa implementasi Objc yang pernah saya lihat.

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

Contoh penggunaan:

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

Mengapa antarmuka makro saat hampir kosong? Konsistensi kode antara file header dan kode; rawatan jika Anda ingin menambahkan lebih banyak metode otomatis atau mengubahnya.

Saya menggunakan metode inisialisasi untuk membuat singleton seperti yang digunakan dalam jawaban paling populer di sini (saat penulisan).

Dengan metode kelas Objective C, kita bisa menghindari menggunakan pola singleton dengan cara biasa, dari:

[[Librarian sharedInstance] openLibrary]

untuk:

[Librarian openLibrary]

dengan membungkus kelas di dalam kelas lain yang hanya memiliki Metode Kelas , dengan cara itu tidak ada kesempatan untuk membuat instance duplikat, karena kita tidak membuat instance apa pun!

Saya menulis blog yang lebih rinci di sini :)

Untuk memperluas contoh dari @ 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;
}

Cara saya sederhana seperti ini:

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

Jika singleton sudah diinisialisasi, blok LOCK tidak akan dimasukkan. Pemeriksaan kedua jika (! Diinisialisasi) adalah untuk memastikan belum diinisialisasi ketika utas saat ini memperoleh KUNCI.

Saya belum membaca semua solusinya, jadi maafkan jika kode ini berlebihan.

Ini adalah implementasi yang paling aman menurut saya.

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

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

    return sharedResourcesObj;
}

Saya biasanya menggunakan kode yang kira-kira mirip dengan jawaban Ben Hoffstein (yang juga saya dapatkan dari Wikipedia). Saya menggunakannya untuk alasan yang dinyatakan oleh Chris Hanson dalam komentarnya.

Namun, kadang-kadang saya memiliki kebutuhan untuk menempatkan singleton ke NIB, dan dalam hal ini saya menggunakan yang berikut:

@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

Saya menyerahkan implementasi -retain(dll) kepada pembaca, meskipun kode di atas adalah semua yang Anda butuhkan di lingkungan sampah yang dikumpulkan.

Jawaban yang diterima, meskipun dikompilasi, salah.

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

Per dokumentasi Apple:

... Anda dapat mengambil pendekatan serupa untuk menyinkronkan metode kelas dari kelas terkait, menggunakan objek Kelas bukan diri.

Bahkan jika menggunakan karya sendiri, seharusnya tidak dan ini terlihat seperti kesalahan salin dan tempel ke saya. Implementasi yang benar untuk metode pabrik kelas adalah:

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