Why does Apple recommend to use dispatch_once for implementing the singleton pattern under ARC?

What’s the exact reason for using dispatch_once in the shared instance accessor of a singleton under ARC?

+ (MyClass *)sharedInstance
{
    //  Static local predicate must be initialized to 0
    static MyClass *sharedInstance = nil;
    static dispatch_once_t onceToken = 0;
    dispatch_once(&onceToken, ^{
        sharedInstance = [[MyClass alloc] init];
        // Do any other initialisation stuff here
    });
    return sharedInstance;
}

Isn’t it a bad idea to instantiate the singleton asynchronously in the background? I mean what happens if I request that shared instance and rely on it immediately, but dispatch_once takes until Christmas to create my object? It doesn’t return immediately right? At least that seems to be the whole point of Grand Central Dispatch.

  • Delegate not working in singleton
  • Correct Singleton Pattern Objective C (iOS)?
  • Difference between static function and singleton class in swift
  • ios singleton class crashes my app
  • Objective-C, Need help creating an AVAudioPlayer singleton
  • Why does the suggested Swift singleton implementation use a struct?
  • So why are they doing this?

    2 Solutions Collect From Internet About “Why does Apple recommend to use dispatch_once for implementing the singleton pattern under ARC?”

    dispatch_once() is absolutely synchronous. Not all GCD methods do things asynchronously (case in point, dispatch_sync() is synchronous). The use of dispatch_once() replaces the following idiom:

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

    The benefit of dispatch_once() over this is that it’s faster. It’s also semantically cleaner, because it also protects you from multiple threads doing alloc init of your sharedInstance–if they all try at the same exact time. It won’t allow two instances to be created. The entire idea of dispatch_once() is “perform something once and only once”, which is precisely what we’re doing.

    Because it will only run once. So if you try and access it twice from different threads it won’t cause a problem.

    Mike Ash has a full description in his Care and Feeding of Singletons blog post.

    Not all GCD blocks are run asynchronously.