Thread Safe C Singleton Pattern

Question

I have some questions regarding the the singleton pattern as documented here  http   msdn microsoft com en-us library ff650316 aspx  The following code is an extract from the article   using System   public sealed class Singleton      private static volatile Singleton instance     private static object syncRoot   new object        private Singleton          public static Singleton Instance            get                   if  instance    null                          lock  syncRoot                                if  instance    null                     instance   new Singleton                                       return instance                   Specifically  in the above example  is there a need to compare instance to null twice  before and after the lock  Is this necessary  Why not perform the lock first and make the comparison   Is there a problem in simplifying to the following      public static Singleton Instance            get                  lock  syncRoot                        if  instance    null                 instance   new Singleton                        return instance                 Is the performing the lock expensive

User · Answer

Another version of Singleton where the following line of code creates the Singleton instance at the time of application startup.

private static readonly Singleton singleInstance = new Singleton();

Here CLR (Common Language Runtime) will take care of object initialization and thread safety. That means we will not require to write any code explicitly for handling the thread safety for a multithreaded environment.

"The Eager loading in singleton design pattern is nothing a process in which we need to initialize the singleton object at the time of application start-up rather than on demand and keep it ready in memory to be used in future."

public sealed class Singleton
    {
        private static int counter = 0;
        private Singleton()
        {
            counter++;
            Console.WriteLine("Counter Value " + counter.ToString());
        }
        private static readonly Singleton singleInstance = new Singleton(); 

        public static Singleton GetInstance
        {
            get
            {
                return singleInstance;
            }
        }
        public void PrintDetails(string message)
        {
            Console.WriteLine(message);
        }
    }

from main :

static void Main(string[] args)
        {
            Parallel.Invoke(
                () => PrintTeacherDetails(),
                () => PrintStudentdetails()
                );
            Console.ReadLine();
        }
        private static void PrintTeacherDetails()
        {
            Singleton fromTeacher = Singleton.GetInstance;
            fromTeacher.PrintDetails("From Teacher");
        }
        private static void PrintStudentdetails()
        {
            Singleton fromStudent = Singleton.GetInstance;
            fromStudent.PrintDetails("From Student");
        }

User · Answer

In almost every case  that is  all cases except the very first ones   instance won t be null  Acquiring a lock is more costly than a simple check  so checking once the value of instance before locking is a nice and free optimization   This pattern is called double-checked locking  http   en wikipedia org wiki Double-checked locking

User · Answer

Jeffrey Richter recommends following        public sealed class Singleton               private static readonly Object s lock   new Object            private static Singleton instance   null               private Singleton                                    public static Singleton Instance                       get                               if instance    null  return instance                  Monitor Enter s lock                   Singleton temp   new Singleton                    Interlocked Exchange ref instance  temp                   Monitor Exit s lock                   return instance

User · Answer

Performing the lock is terribly expensive when compared to the simple pointer check instance    null   The pattern you see here is called double-checked locking  Its purpose is to avoid the expensive lock operation which is only going to be needed once  when the singleton is first accessed   The implementation is such because it also has to ensure that when the singleton is initialized there will be no bugs resulting from thread race conditions   Think of it this way  a bare null check  without a lock  is guaranteed to give you a correct usable answer only when that answer is  yes  the object is already constructed   But if the answer is  not constructed yet  then you don t have enough information because what you really wanted to know is that it s  not constructed yet and no other thread is intending to construct it shortly   So you use the outer check as a very quick initial test and you initiate the proper  bug-free but  expensive  procedure  lock then check  only if the answer is  no    The above implementation is good enough for most cases  but at this point it s a good idea to go and read Jon Skeet s article on singletons in C  which also evaluates other alternatives

User · Answer

Performing a lock  Quite cheap  still more expensive than a null test    Performing a lock when another thread has it  You get the cost of whatever they ve still to do while locking  added to your own time   Performing a lock when another thread has it  and dozens of other threads are also waiting on it  Crippling   For performance reasons  you always want to have locks that another thread wants  for the shortest period of time at all possible   Of course it s easier to reason about  broad  locks than narrow  so it s worth starting with them broad and optimising as needed  but there are some cases that we learn from experience and familiarity where a narrower fits the pattern    Incidentally  if you can possibly just use private static volatile Singleton instance   new Singleton   or if you can possibly just not use singletons but use a static class instead  both are better in regards to these concerns

User · Answer

Reflection resistant Singleton pattern  public sealed class Singleton       public static Singleton Instance   gt   lazy Value      private static Lazy lt Singleton  Func lt int gt  gt   lazy   get         static Singleton                 var i   0           lazy   new Lazy lt Singleton  Func lt int gt  gt       gt                        i                return new Singleton                    gt  i              private Singleton                 if   lazy Metadata      0     lazy IsValueCreated              throw new Exception  quot Singleton creation exception quot               public void Run                 Console WriteLine  quot Singleton called quot

User · Answer

This is called Double checked locking mechanism  first  we will check whether the instance is created or not  If not then only we will synchronize the method and create the instance  It will drastically improve the performance of the application  Performing lock is heavy  So to avoid the lock first we need to check the null value  This is also thread safe and it is the best way to achieve the best performance  Please have a look at the following code   public sealed class Singleton       private static readonly object Instancelock   new object        private Singleton                   private static Singleton instance   null       public static Singleton GetInstance               get                       if  instance    null                                lock  Instancelock                                        if  instance    null                                                instance   new Singleton                                                                      return instance

User · Answer

The reason is performance  If instance    null  which will always be the case except the very first time   there is no need to do a costly lock  Two threads accessing the initialized singleton simultaneously would be synchronized unneccessarily

User · Answer

You could eagerly create the a thread-safe Singleton instance  depending on your application needs  this is succinct code  though I would prefer  andasa s lazy version   public sealed class Singleton       private static readonly Singleton instance   new Singleton         private Singleton            public static Singleton Instance                 return instance

User · Answer

The Lazy lt T gt  version   public sealed class Singleton       private static readonly Lazy lt Singleton gt  lazy           new Lazy lt Singleton gt       gt  new Singleton          public static Singleton Instance           gt  lazy Value       private Singleton           Requires  NET 4 and C  6 0  VS2015  or newer

[c#] Thread Safe C# Singleton Pattern

Examples related to c#

Examples related to design-patterns

Examples related to singleton