在Objective-C中使用GCD的dispatch_once创建单例

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

#1 楼

这是创建类实例的一种完全可接受且线程安全的方法。从技术上讲，它可能不是一个“单例”（因为这些对象只能有一个），但是只要您仅使用[Foo sharedFoo]方法访问该对象，就足够了。

#2 楼

instancetype
instancetype只是Objective-C的众多语言扩展之一，每个新发行版都添加了更多扩展。
知道它，喜欢它。
并以此为例来说明如何关注底层细节可以使您深入了解转换Objective-C的强大新方法。
请参阅：instancetype

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

#3 楼

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

#4 楼

您可以通过覆盖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;
}

#5 楼

戴夫是正确的，那很好。您可能想查看Apple的创建单例文档，以获取有关实现其他一些方法的提示，以确保如果类选择不使用sharedFoo方法，则只能创建一个。

#6 楼

如果您想确保[[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的任何调用都将完全忽略返回的alloc并返回相同的sharedInstance；分配的结果将被释放。

+ sharedInstance方法将像往常一样工作。如果不是第一个调用[[MyClass alloc] init]的调用者，则init的结果不是alloc调用的结果，但是可以。

#7 楼

您问这是否是“创建单例的最佳方法”。

一些想法：


首先，是的，这是线程安全的解决方案。这种dispatch_once模式是在Objective-C中生成单例的现代线程安全方式。在那里不用担心。

但是，您问这是否是“最佳”方法。但是，应该承认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看起来将支持子类，但不会。如果您打算支持子类化，则至少要包含一些文档，这些文档会警告未来的开发人员他们必须重写此方法。


为实现与Swift的最佳互操作性，您可能希望将其定义为属性，而不是类方法，例如：

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

然后您可以继续为此属性编写吸气剂（实现将使用您建议的dispatch_once模式） ：

+ (Foo *)sharedFoo { ... }

这样的好处是，如果Swift用户去使用它，他们会做类似的事情：

let foo = Foo.shared

注意，没有()，因为我们将其实现为属性。从Swift 3开始，这就是通常访问单例的方式。因此，将其定义为属性有助于促进这种互操作性。

顺便说一句，如果您看看苹果如何定义他们的单身人士，这就是他们采用的模式，例如他们的NSURLSession单例定义如下：

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

另外一个非常小的Swift互操作性考虑因素是单例的名称。最好是可以合并类型的名称，而不是sharedInstance。例如，如果类为Foo，则可以将singleton属性定义为sharedFoo。或者，如果类是DatabaseManager，则可以调用属性sharedManager。然后，Swift用户可以执行以下操作：

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

很显然，如果您真的想使用sharedInstance，则始终可以在需要时声明Swift名称：
<显然，在编写Objective-C代码时，我们不应该让Swift的互操作性超过其他设计考虑因素，但是，如果我们可以编写能够优雅地支持两种语言的代码，那是更好的选择。

我同意其他人的看法，他们指出，如果您希望这是一个真正的单例，开发人员无法（不应）实例化自己的实例，则unavailable和init上的new限定符为谨慎。

#8 楼

要创建线程安全的单例，您可以这样操作：

@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中很好地说明了单例

#9 楼

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

#10 楼

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