Chiếc singleton Objective-C của tôi trông như thế nào? [đóng cửa]

Phương thức truy cập đơn lẻ của tôi thường là một số biến thể của:

static MyClass *gInstance = NULL;

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

    return(gInstance);
}

Tôi có thể làm gì để cải thiện điều này?

Một lựa chọn khác là sử dụng +(void)initializephương pháp. Từ tài liệu:

Thời gian chạy gửi initializeđến mỗi lớp trong một chương trình chính xác một lần ngay trước lớp hoặc bất kỳ lớp nào kế thừa từ nó, được gửi tin nhắn đầu tiên từ bên trong chương trình. (Do đó phương thức có thể không bao giờ được gọi nếu lớp không được sử dụng.) Thời gian chạy gửi initializetin nhắn đến các lớp theo cách an toàn luồng. Các siêu lớp nhận được thông báo này trước các lớp con của chúng.

Vì vậy, bạn có thể làm một cái gì đó giống như thế này:

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

[Nguồn]

Theo câu trả lời khác của tôi dưới đây, tôi nghĩ bạn nên làm:

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

Vì Kendall đã đăng một singleton singleton cố gắng tránh khóa chi phí, tôi nghĩ tôi cũng sẽ ném nó lên:

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

Được rồi, hãy để tôi giải thích làm thế nào điều này hoạt động:

1. Trường hợp nhanh: Trong thực thi bình thường sharedInstanceđã được thiết lập, do đó whilevòng lặp không bao giờ được thực thi và hàm trả về sau khi chỉ cần kiểm tra sự tồn tại của biến;

2. Trường hợp chậm: Nếu sharedInstancekhông tồn tại, thì một thể hiện được phân bổ và sao chép vào nó bằng cách sử dụng So sánh và hoán đổi ('CAS');

3. Trường hợp dự kiến: Nếu cả hai luồng cố gắng gọi sharedInstancecùng một lúc VÀ sharedInstance không tồn tại cùng một lúc thì cả hai sẽ khởi tạo các thể hiện mới của singleton và cố gắng đưa CAS vào vị trí. Bất cứ ai thắng CAS đều trả về ngay lập tức, bất kỳ ai thua sẽ giải phóng thể hiện mà nó vừa phân bổ và trả về (hiện được đặt) sharedInstance. Đơn OSAtomicCompareAndSwapPtrBarrierđóng vai trò vừa là rào cản ghi cho luồng cài đặt vừa là rào cản đọc từ luồng thử nghiệm.

MyClass tĩnh * sharedInst = nil;

+ (id) sharedInstance
{
    @synyncize (tự) {
        if (sharedInst == nil) {
            / * sharedInst được thiết lập trong init * /
            [[tự phân bổ] init];
        }
    }
    trả lại chia sẻInst;
}

- (id) init
{
    if (sharedInst! = nil) {
        [Nâng cao NSException: NSIternalInconsistencyException
            định dạng: @ "[% @% @] không thể được gọi; sử dụng + [% @% @] thay vào đó"],
            NSStringFromClass ([lớp tự]], NSStringFromSelector (_cmd), 
            NSStringFromClass ([lớp tự]],
            NSStringFromSelector (@selector (sharedInstance) "];
    } if if (self = [super init]) {
        sharedInst = tự;
        / * Bất cứ lớp học cụ thể nào ở đây * /
    }
    trả lại chia sẻInst;
}

/ * Những thứ này có lẽ không làm gì cả
   một ứng dụng GC. Giữ đơn
   như một người độc thân thực sự trong một
   ứng dụng không phải CG
* /
- (NSUInteger) keepCount
{
    trả lại NSUIntegerMax;
}

- phát hành (oneway void)
{
}

- (id) giữ lại
{
    trả lại chia sẻInst;
}

- (id) tự động thoát
{
    trả lại chia sẻInst;
}

Chỉnh sửa: Việc triển khai này đã lỗi thời với ARC. Xin vui lòng xem Làm thế nào để tôi triển khai một singleton Objective-C tương thích với ARC? để thực hiện đúng.

Tất cả các triển khai khởi tạo Tôi đã đọc trong các câu trả lời khác đều có chung một lỗi.

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

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

Tài liệu của Apple khuyên bạn nên kiểm tra loại lớp trong khối khởi tạo của mình. Bởi vì các lớp con gọi khởi tạo theo mặc định. Tồn tại một trường hợp không rõ ràng trong đó các lớp con có thể được tạo gián tiếp thông qua KVO. Vì nếu bạn thêm dòng sau vào một lớp khác:

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

Objective-C sẽ ngầm tạo một lớp con của MySingletonClass dẫn đến việc kích hoạt lần thứ hai +initialize.

Bạn có thể nghĩ rằng bạn nên ngầm kiểm tra việc khởi tạo trùng lặp trong khối init của mình như sau:

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

Nhưng bạn sẽ tự bắn vào chân mình; hoặc tệ hơn là cho một nhà phát triển khác cơ hội tự bắn vào chân mình.

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

TL; DR, đây là triển khai của tôi

@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

(Thay thế ZAssert bằng macro xác nhận riêng của chúng tôi; hoặc chỉ NSAssert.)

Một lời giải thích kỹ lưỡng về mã macro Singleton có trên blog Ca cao với tình yêu

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

Tôi có một biến thể thú vị trên sharedInstance là luồng an toàn, nhưng không khóa sau khi khởi tạo. Tôi chưa chắc chắn đủ để sửa đổi câu trả lời hàng đầu theo yêu cầu, nhưng tôi trình bày nó để thảo luận thêm:

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

Câu trả lời ngắn gọn: Tuyệt vời.

Câu trả lời dài: Một cái gì đó như ....

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

Hãy chắc chắn đọc tiêu đề công văn / một lần.h để hiểu những gì đang xảy ra. Trong trường hợp này, các bình luận tiêu đề được áp dụng nhiều hơn các tài liệu hoặc trang man.

Tôi đã cuộn singleton vào một lớp, vì vậy các lớp khác có thể kế thừa các thuộc tính của 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

Và đây là một ví dụ về một số lớp, rằng bạn muốn trở thành người độc thân.

#import "Singleton.h"

@interface SomeClass : Singleton {

}

@end

@implementation SomeClass 

DEFINE_SHARED_INSTANCE;

@end

Hạn chế duy nhất về lớp Singleton, đó là lớp con NSObject. Nhưng hầu hết thời gian tôi sử dụng singletons trong mã của mình, chúng thực tế là các lớp con NSObject, vì vậy lớp này thực sự dễ dàng cho cuộc sống của tôi và làm cho mã sạch hơn.

Điều này cũng hoạt động trong một môi trường không thu gom rác.

@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

Đây không phải là chủ đề an toàn và tránh khóa đắt tiền sau cuộc gọi đầu tiên?

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

Đây là một macro mà tôi kết hợp lại:

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

Nó dựa trên công việc ở đây của Matt Gallagher Nhưng việc thay đổi cách triển khai để sử dụng phương pháp làm mờ như mô tả ở đây bởi Dave MacLachlan của Google .

Tôi hoan nghênh ý kiến ​​/ đóng góp.

Làm thế nào về

static MyClass *gInstance = NULL;

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

    return(gInstance);
}

Vì vậy, bạn tránh chi phí đồng bộ hóa sau khi khởi tạo?

Để thảo luận chuyên sâu về mẫu đơn trong Objective-C, xem tại đây:

Sử dụng mẫu Singleton trong Objective-C

KLSingleton là:

1. Phân lớp (đến mức thứ n)
2. Tương thích ARC
3. An toàn với allocvàinit
4. Tải một cách lười biếng
5. An toàn chủ đề
6. Khóa miễn phí (sử dụng + khởi tạo, không phải @ đồng bộ hóa)
7. Không có vĩ mô
8. Không có sóng gió
9. Đơn giản

KLSingleton

Bạn không muốn tự đồng bộ hóa ... Vì đối tượng tự chưa tồn tại! Bạn cuối cùng khóa trên một giá trị id tạm thời. Bạn muốn đảm bảo rằng không ai khác có thể chạy các phương thức lớp (sharedInstance, alloc, allocWithZone:, v.v.), vì vậy bạn cần phải đồng bộ hóa trên đối tượng lớp thay thế:

@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

Chỉ muốn để nó ở đây vì vậy tôi không mất nó. Ưu điểm của cái này là nó có thể sử dụng được trong InterfaceBuilder, đây là một lợi thế lớn. Điều này được lấy từ một câu hỏi khác mà tôi đã hỏi :

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

Tôi biết có rất nhiều ý kiến ​​về "câu hỏi" này, nhưng tôi không thấy nhiều người đề xuất sử dụng macro để định nghĩa singleton. Đó là một mô hình phổ biến và một macro đơn giản hóa rất nhiều cho singleton.

Dưới đây là các macro tôi đã viết dựa trên một số triển khai Objc mà tôi đã thấy.

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

Ví dụ sử dụng:

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

Tại sao một macro giao diện khi nó gần như trống rỗng? Mã thống nhất giữa các tệp tiêu đề và mã; khả năng bảo trì trong trường hợp bạn muốn thêm các phương thức tự động hơn hoặc thay đổi nó xung quanh.

Tôi đang sử dụng phương thức khởi tạo để tạo ra singleton như được sử dụng trong câu trả lời phổ biến nhất ở đây (tại thời điểm viết).

Với các phương thức lớp C khách quan, chúng ta có thể tránh sử dụng mẫu singleton theo cách thông thường, từ:

[[Librarian sharedInstance] openLibrary]

đến:

[Librarian openLibrary]

bằng cách gói lớp bên trong một lớp khác chỉ có Phương thức lớp , theo cách đó, không có cơ hội vô tình tạo các thể hiện trùng lặp, vì chúng tôi không tạo ra bất kỳ trường hợp nào!

Tôi đã viết một blog chi tiết hơn ở đây :)

Để mở rộng ví dụ từ @ 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;
}

Cách của tôi rất đơn giản như thế này:

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

Nếu singleton đã được khởi tạo, khối LOCK sẽ không được nhập. Kiểm tra thứ hai nếu (! Khởi tạo) là để đảm bảo rằng nó chưa được khởi tạo khi luồng hiện tại mua LOCK.

Tôi đã không đọc qua tất cả các giải pháp, vì vậy hãy tha thứ nếu mã này là dư thừa.

Đây là chủ đề thực hiện an toàn nhất theo ý kiến ​​của tôi.

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

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

    return sharedResourcesObj;
}

Tôi thường sử dụng mã gần giống với mã trong câu trả lời của Ben Hoffstein (mà tôi cũng đã thoát ra khỏi Wikipedia). Tôi sử dụng nó cho các lý do được nêu bởi Chris Hanson trong bình luận của mình.

Tuy nhiên, đôi khi tôi có nhu cầu đặt một singleton vào NIB và trong trường hợp đó tôi sử dụng như sau:

@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

Tôi để việc thực hiện -retain(v.v.) cho người đọc, mặc dù đoạn mã trên là tất cả những gì bạn cần trong một môi trường thu gom rác.

Câu trả lời được chấp nhận, mặc dù nó biên dịch, là không chính xác.

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

Theo tài liệu của Apple:

... Bạn có thể thực hiện một cách tiếp cận tương tự để đồng bộ hóa các phương thức lớp của lớp được liên kết, sử dụng đối tượng Class thay vì tự.

Ngay cả khi sử dụng tự hoạt động, nó không nên và nó trông giống như một bản sao và dán nhầm với tôi. Việc thực hiện đúng cho một phương thức nhà máy lớp sẽ là:

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