C＃中的单例线程安全 - 为什么要添加双重检查？

Question

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

I don't understand why is the double check ! I read that this double check is to solve the thread concurrency problems - but ...

1. The lock will solve it - so why we need to first 'if'

2. if this singleton will be without the first 'if' it still will be thread safe - right ?

3. if the first 'if' is false - so thread1 will init the 'instance' object => now, the 'instance' is not null and the thread1 is still in the lock block ===>> now, thread2 check the first 'if' and will get false => so he will not get to the 'lock' and imminently will return the instance and thread2 is able to change properties of the 'instance' => so thread1 && thread2 are 'working' on same 'instance' object => so where is the thread safe ... or what I'm missing here.

Answer 1

1.The lock will solve it - so why we need to first 'if'

So you won't lock the thred unless you need to create the new instance of the Singleton.
lock is a very expensive operation , so it's worth doing that extra check.

2.if this singleton will be without the first 'if' it still will be thread safe - right ?

Yes, but significantly slower.

3.Thread1 && thread2 are 'working' on same 'instance' object => so where is the thread safe

This is the whole point of singleton, only one instance for all threads. That's the thread safe thing...

Answer 2

I assume that if ThreadA gets interrupted just before the lock ; ThreadB successfully completes the creation of the singleton then when ThreadA resumes it'll try to recreate the singleton once the lock is released.

Answer 3

the if checks if the singleton is already instantiated if not it create a new instace. and the lock ensure threadsafety.

without the if it would create a new instace on every call (not the idea of singleton). without the lock it would be able that two threads could simulatanusly create a instance, so it would be possible that two instances exists.

if you are only using single threading you can wipe the lock. otherwise (on mt) it's highly recommended to use it.

Answer 4

Here is a good paper from the University of Maryland on why it is recommended (and why it does not always work in modern optimizing compilers) This is a good read if you have time.

http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html