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

Question

如果您可以

使用 GCD 面向 iOS 4.0 或更高版本，那么这是在 Objective-C 中创建单例（线程安全）的最佳方法吗？

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

Answer 1

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

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

Answer 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

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

Answer 5

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

Answer 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 方法中。以后对 init 的任何调用都将完全忽略 alloc 返回的内容并返回相同的共享实例； alloc 的结果将被释放。

+sharedInstance 方法将像往常一样工作。如果它不是第一个调用 [[MyClass alloc] init] 的调用者，那么 init 的结果不是 alloc 调用的结果，但这没关系。

Answer 7

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

一些想法：

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

2. 不过，您问这是否是“最佳”方法。不过，应该承认，instancetype 和 [[self alloc] init] 在与单例结合使用时可能会产生误导。

   instancetype 的好处是，它是一种明确的方式来声明该类可以被子类化，而无需求助于 id 类型，就像我们过去必须做的那样.

   但是此方法中的静态带来了子类化挑战。如果 ImageCache 和 BlobCache 单例都是 Cache 超类的子类，而不实现自己的 sharedCache 方法，该怎么办？ p>

   ImageCache *imageCache = [ImageCache共享缓存]; // 美好的
   BlobCache *blobCache = [BlobCache 共享缓存]; // 错误;这将返回前面提到的 ImageCache！！！
   

   为此，您必须确保子类实现自己的 sharedInstance （或您为特定类调用的任何方法）。

   底线，您原来的 sharedInstance 看起来它将支持子类，但事实并非如此。如果您打算支持子类化，至少要包含警告未来开发人员必须重写此方法的文档。

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

   @interface Foo : NSObject
   @property（类，只读，强）Foo *sharedFoo;
   @结尾
   

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

   + (Foo *)sharedFoo { ... }
   

   这样做的好处是，如果 Swift 用户要使用它，他们会执行以下操作：

   let foo = Foo.shared
   

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

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

   @property（类，只读，强）NSURLSession *sharedSession;
   

4. 另一个非常小的 Swift 互操作性考虑因素是单身人士的名字。最好可以合并类型的名称，而不是 sharedInstance。例如，如果类是 Foo，您可以将单例属性定义为 sharedFoo。或者，如果类是DatabaseManager，您可以调用属性sharedManager。那么 Swift 用户可以这样做：

   let foo = Foo.shared
   让管理器 = DatabaseManager.shared
   

   显然，如果您确实想使用 sharedInstance，您可以随时声明 Swift 名称：

   @property（类，只读，强）Foo*sharedInstance NS_SWIFT_NAME（共享）；
   

   显然，在编写 Objective-C 代码时，我们不应该让 Swift 的互操作性凌驾于其他设计考虑之上，但是，如果我们能够编写能够优雅地支持两种语言的代码，那就更好了。

5. 我同意其他人的观点，他们指出，如果您希望这是一个真正的单例，而开发人员不能/不应该（意外地）实例化他们自己的实例，则 上的 unavailable 限定符>init 和 new 是谨慎的。

Answer 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 中的单例< /a>

Answer 9

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

Answer 10

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