Comments on: Singletons in Cocoa/Objective-C

By: Carlo

Carlo — Fri, 16 Dec 2011 01:14:01 +0000

This is very very interesting. I'm in the situation that I want to create a global "manager" to manage Core Data (all the methods to access Core Data in the delegate make me really uncomfortable). Now I'm wondering: what is the right thing to do if singleton is bad?

By: Shea Ako

Shea Ako — Fri, 21 Oct 2011 17:18:25 +0000

addendum to my previous comment - I meant to say,

I use the first method described in the article and put a lock around:

   if (sharedManager == nil) {...}

By: Shea Ako

Shea Ako — Fri, 21 Oct 2011 17:16:01 +0000

I've run into a situation that demonstrates that the example published here is not actually thread safe.

Two threads call +sharedManager at (more or less) the same time. The earlier call to +sharedManager triggers +initialize on its thread, but before +initialize completes the second thread executes +sharedManager.

When +sharedManager is called on the second thread it can return nil if +initialize hasn't finished yet on the first thread.

Using some sort of locking is necessary for thread safety.

I use a lock in +sharedManager.around

   if (sharedManager == nil) {...}

By: Charles Parnot

Charles Parnot — Fri, 19 Aug 2011 22:08:31 +0000

Is this thread-safe?

@implementation Foo

static id sharedInstance;

+(id)sharedInstance
{
    if (sharedInstance)
        return sharedInstance;

    @synchronized(self)
    {
        if (!sharedInstance)
            sharedInstance = [[self alloc] init];
    }
    return sharedInstance;
}

@end

By: Otto Schnurr

Otto Schnurr — Tue, 28 Sep 2010 18:54:51 +0000

@scott: When a static variable is declared inside a function, it's only initialized the first time the function is executed.

By: Fred McCann

Fred McCann — Fri, 21 May 2010 22:40:07 +0000

I’ve written up an in-depth discussion of the singleton pattern here:

http://www.duckrowing.com/2010/05/21/using-the-singleton-pattern-in-objective-c/

By: bangnoise

bangnoise — Mon, 01 Feb 2010 11:32:28 +0000

But your singleton isn't a singleton at all - you can [[SomeManager alloc] init] as many instances as you like. The point of the Apple way which overrides allocWithZone: is to enforce singleton behaviour - if that's not important to a singleton class, it maybe doesn't need to be a singleton anyway.

@synchronized([SomeManager class]) { }

Is an improvement on Apple's example locking, I think..?

By: Dustin L. Howett

Dustin L. Howett — Sat, 23 Jan 2010 20:46:52 +0000

Amending my last comment: "Except for the case in which a subclass of yours does not provide +initialize."

By: Dustin L. Howett

Dustin L. Howett — Sat, 23 Jan 2010 20:35:01 +0000

There's actually no way for +initialize to be called with a self that isn't the class +initialize belongs to, by the runtime. The runtime calls initialize in reverse order for the entire superclass tree (assuming that class has not already been initialized) and does not call "[super initialize]." +initialize is called once and only once for every class, as noted in the Apple documentation. The if(self == [SomeManager class]) guard is therefore unnecessary.

By: Kaelin

Kaelin — Wed, 07 Oct 2009 01:27:18 +0000

GCD now offers the possibility of doing this with dispatch_once(). This is almost certainly the most performant technique that's both thread-safe and concise:

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

By: scott lewis

scott lewis — Sun, 27 Sep 2009 11:53:42 +0000

correct me if I'm wrong, but there seems to be a typo in the very first example as the static declaration is inside the class method, which means it will always be set to nil, and thus not really work as a "somewhat" singleton. Is that correct?

By: eschaton

eschaton — Mon, 06 Jul 2009 21:20:13 +0000

You really shouldn't need to be worried about performance of singleton objects.

By: Mo Ayazifar

Mo Ayazifar — Mon, 29 Jun 2009 21:22:47 +0000

Then finally which one is gonna be the best one regarding to performance? and how are we supposed to use them form outside? is there any sample code available for that?

By: eschaton

eschaton — Thu, 18 Jun 2009 05:21:14 +0000

Yeah; using @synchronized (self) in a class method that could be invoked on a subclass is risky.

I reformatted your code into Markdown, since it didn't survive the HTML editor widget thingy.

By: Clark Cox

Clark Cox — Thu, 18 Jun 2009 05:13:40 +0000

(Of course, that doesn't address the subclassing issue that you mentioned)

By: Clark Cox

Clark Cox — Thu, 18 Jun 2009 05:07:05 +0000

Another way to make a singleton, that is still lazily loaded, thread-safe and only incurs the cost of synchronization once (i.e. it's like a double-checked lock, except that it actually works):

@implementation Foo

static id sharedInstance;

+(id)sharedInstance {
    @synchronized(self) {
        if(!sharedInstance) {
            sharedInstance = [[self alloc] init];
            class_replaceMethod(object_getClass(self),
                @selector(sharedInstance),
                [self methodForSelector: @selector(sharedInstance2)],
                "@@:");
        }
    }

    return sharedInstance;
}

+(id)sharedInstance2 {
    return sharedInstance;
}

@end