What should my Objective-C singleton look like

Question

My singleton accessor method is usually some variant of   static MyClass  gInstance   NULL      MyClass   instance        synchronized self                if  gInstance    NULL              gInstance     self alloc  init              return gInstance       What could I be doing to improve this

User · Accepted Answer

Another option is to use the   void initialize method   From the documentation      The runtime sends initialize to each class in a program exactly one time just before the class  or any class that inherits from it  is sent its first message from within the program   Thus the method may never be invoked if the class is not used   The runtime sends the initialize message to classes in a thread-safe manner  Superclasses receive this message before their subclasses    So you could do something akin to this   static MySingleton  sharedSingleton      void initialize       static BOOL initialized   NO      if  initialized                initialized   YES          sharedSingleton     MySingleton alloc  init

User · Answer

How about   static MyClass  gInstance   NULL      MyClass   instance       if  gInstance    NULL             synchronized self                        if  gInstance    NULL                  gInstance     self alloc  init                        return gInstance       So you avoid the synchronization cost after initialization

User · Answer

I have an interesting variation on sharedInstance that is thread safe  but does not lock after the initialization   I am not yet sure enough of it to modify the top answer as requested  but I present it for further discussion      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

User · Answer

Just wanted to leave this here so I don t lose it  The advantage to this one is that it s usable in InterfaceBuilder  which is a HUGE advantage  This is taken from another question that I asked   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

User · Answer

I ve not read through all the solutions  so forgive if this code is redundant    This is the most thread safe implementation in my opinion      SingletonObject    sharedManager       static SingletonObject   sharedResourcesObj   nil        synchronized self                if   sharedResourcesObj                        sharedResourcesObj     SingletonObject alloc  init                        return sharedResourcesObj

User · Answer

You don t want to synchronize on self    Since the self object doesn t exist yet  You end up locking on a temporary id value  You want to ensure that no one else can run class methods   sharedInstance  alloc  allocWithZone   etc    so you need to synchronize on the class object instead    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

User · Answer

With Objective C class methods  we can just avoid using the singleton pattern the usual way  from     Librarian sharedInstance  openLibrary    to    Librarian openLibrary    by wrapping the class inside another class that just has Class Methods  that way there is no chance of accidentally creating duplicate instances  as we re not creating any instance   I wrote a more detailed blog here

User · Answer

Short answer  Fabulous   Long answer  Something like      static SomeSingleton  instance   NULL    implementation SomeSingleton     id  instance       static dispatch once t onceToken      dispatch once  amp 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   Be sure to read the dispatch once h header to understand what s going on  In this case the header comments are more applicable than the docs or man page

User · Answer

Since Kendall posted a threadsafe singleton that attempts to avoid locking costs  I thought I would toss one up as well    import  lt libkern OSAtomic h gt   static void   volatile sharedInstance   nil                                                      className    sharedInstance                                                                         while   sharedInstance                                                                                  className  temp     self alloc  init                                                                        if  OSAtomicCompareAndSwapPtrBarrier 0x0  temp   amp sharedInstance            temp release                                                                                                                                                                                                                                                                                                              return sharedInstance                                                                              Okay  let me explain how this works    Fast case  In normal execution sharedInstance has already been set  so the while loop is never executed and the function returns after simply testing for the variable s existence  Slow case  If sharedInstance doesn t exist  then an instance is allocated and copied into it using a Compare And Swap   CAS    Contended case  If two threads both attempt to call sharedInstance at the same time AND sharedInstance doesn t exist at the same time then they will both initialize new instances of the singleton and attempt to CAS it into position  Whichever one wins the CAS returns immediately  whichever one loses releases the instance it just allocated and returns the  now set  sharedInstance  The single OSAtomicCompareAndSwapPtrBarrier acts as both a write barrier for the setting thread and a read barrier from the testing thread

User · Answer

interface MySingleton   NSObject         MySingleton   sharedSingleton   end   implementation MySingleton     MySingleton   sharedSingleton     static MySingleton  sharedSingleton      synchronized self          if   sharedSingleton        sharedSingleton     MySingleton alloc  init        return sharedSingleton          end    Source

User · Answer

KLSingleton is          Subclassible  to the n-th degree    ARC compatible   Safe with alloc and init   Loaded lazily   Thread-safe   Lock-free  uses  initialize  not  synchronize    Macro-free   Swizzle-free   Simple      KLSingleton

User · Answer

To extend the example from  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

User · Answer

Here s a macro that I put together   http   github com cjhanson Objective-C-Optimized-Singleton  It is based on the work here by Matt Gallagher But changing the implementation to use method swizzling as described here by Dave MacLachlan of Google   I welcome comments   contributions

User · Answer

I usually use code roughly similar to that in Ben Hoffstein s answer  which I also got out of Wikipedia   I use it for the reasons stated by Chris Hanson in his comment   However  sometimes I have a need to place a singleton into a NIB  and in that case I use the following    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   I leave the implementation of -retain  etc   to the reader  although the above code is all you need in a garbage collected environment

User · Answer

Edit  This implementation obsoleted with ARC  Please have a look at How do I implement an Objective-C singleton that is compatible with ARC  for correct implementation   All the implementations of initialize I ve read in other answers share a common error      void  initialize      instance     MySingletonClass alloc  init      lt ----- Wrong        void  initialize     if  self     MySingletonClass class        lt ----- Correct         instance     MySingletonClass alloc  init           The Apple documentation recommend you check the class type in your initialize block  Because subclasses call the initialize by default  There exists a non-obvious case where subclasses may be created indirectly through KVO  For if you add the following line in another class     MySingletonClass getInstance  addObserver self forKeyPath   foo  options 0 context nil    Objective-C will implicitly create a subclass of MySingletonClass resulting in a second triggering of  initialize   You may think that you should implicitly check for duplicate initialization in your init block as such   -  id  init    lt ----- Wrong     if   instance    nil             Some hack         else            Do stuff        return self      But you will shoot yourself in the foot  or worse give another developer the opportunity to shoot themselves in the foot   -  id  init    lt ----- Correct     NSAssert  instance    nil    Duplication initialization of singleton       self    super init      if  self            Do stuff         return self      TL DR  here s my implementation   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    Replace ZAssert with our own assertion macro  or just NSAssert

User · Answer

For an in-depth discussion of the singleton pattern in Objective-C  look here   Using the Singleton Pattern in Objective-C

User · Answer

A thorough explanation of the Singleton macro code is on the blog Cocoa With Love  http   cocoawithlove com 2008 11 singletons-appdelegates-and-top-level html

User · Answer

My way is simple like this   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      If the singleton is initialized already  the LOCK block will not be entered  The second check if  initialized  is to make sure it is not initialized yet when the current thread acquires the LOCK

User · Answer

The accepted answer  although it compiles  is incorrect      MySingleton  sharedInstance        synchronized self    lt -------- self does not exist at class scope               if  sharedInstance    nil              sharedInstance     MySingleton alloc  init             return sharedInstance      Per Apple documentation       You can take a similar approach to synchronize the class methods of the associated class  using the Class object instead of self   Even if using self works  it shouldn t and this looks like a copy and paste mistake to me  The correct implementation for a class factory method would be      MySingleton  getInstance        synchronized  MySingleton class                  if  sharedInstance    nil              sharedInstance     MySingleton alloc  init             return sharedInstance

User · Answer

This works in a non-garbage collected environment also    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

User · Answer

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

User · Answer

Per my other answer below  I think you should be doing      id sharedFoo       static dispatch once t once      static MyFoo  sharedFoo      dispatch once  amp once      sharedFoo     self alloc  init           return sharedFoo

User · Answer

Shouln t this be threadsafe and avoid the expensive locking after the first call      MySingleton  sharedInstance       if  sharedInstance    nil             synchronized self                if  sharedInstance    nil                    sharedInstance     MySingleton alloc  init                                     return  MySingleton   sharedInstance

User · Answer

I know there are a lot of comments on this  question   but I don t see many people suggesting using a macro to define the singleton   It s such a common pattern and a macro greatly simplifies the singleton   Here are the macros I wrote based on several Objc implementations I ve seen   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        Example of use   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   Why a interface macro when it s nearly empty   Code consistency between the header and code files  maintainability in case you want to add more automatic methods or change it around   I m using the initialize method to create the singleton as is used in the most popular answer here  at time of writing

User · Answer

static MyClass  sharedInst   nil      id sharedInstance        synchronize  self             if   sharedInst    nil                    sharedInst set up in init                  self alloc  init                       return sharedInst     -  id init       if   sharedInst    nil              NSException raise NSInternalInconsistencyException             format           cannot be called  use          instead                NSStringFromClass  self class    NSStringFromSelector  cmd                NSStringFromClass  self class                NSStringFromSelector  selector sharedInstance           else if   self    super init              sharedInst   self             Whatever class specific here              return sharedInst        These probably do nothing in    a GC app   Keeps singleton    as an actual singleton in a    non CG app    -  NSUInteger retainCount       return NSUIntegerMax     -  oneway void release      -  id retain       return sharedInst     -  id autorelease       return sharedInst

User · Answer

I ve rolled singleton into a class  so other classes can inherit singleton properties   Singleton h    static id sharedInstance   nil    define DEFINE SHARED INSTANCE    id  sharedInstance    return  self sharedInstance  amp sharedInstance                                         id  allocWithZone  NSZone   zone   return  self allocWithZone zone forInstance  amp 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  amp 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   And here is an example of some class  that you want to become singleton    import  Singleton h    interface SomeClass   Singleton        end   implementation SomeClass   DEFINE SHARED INSTANCE    end   The only limitation about Singleton class  is that it is NSObject subclass  But most time I use singletons in my code they are in fact NSObject subclasses  so this class really ease my life and make code cleaner

[objective-c] What should my Objective-C singleton look like?

Examples related to objective-c

Examples related to design-patterns

Examples related to singleton

Examples related to object-initializers