title: Difference between these two Singleton implementations
body: <p>I am learning how to implement some basic design patterns. Whilst learning the Singleton pattern I have noticed that there are two common implementations on the web:</p>
  
  <pre><code>// Possibly from: http://www.yoda.arachsys.com/csharp/singleton.html
  // I cannot remember exact source, sorry :(
  
  public sealed class Singleton
  {
      // Static members are 'eagerly initialized', that is,
      // immediately when class is loaded for the first time.
      // .NET guarantees thread safety for static initialization
      private static readonly Singleton instance = new Singleton();
  
      // Private constructor prevents instantiation from other classes
      private Singleton() { }
  
      // Explicit static constructor to tell C# compiler
      // not to mark type as beforefieldinit
      public static Singleton() { }
  
      // Get the instance of the singleton
      public static Singleton getInstance()
      {
              return instance;
      }
  
  }
  </code></pre>
  
  <p>and: </p>
  
  <pre><code>public class Singleton
  {
    // Static, VOLATILE variable to store single instance
    private static volatile Singleton m_instance;
  
    // Static synchronization root object, for locking
    private static object m_syncRoot = new object();
  
    // Property to retrieve the only instance of the Singleton
    public static Singleton Instance
     {
        get
        {
            // Check that the instance is null
            if (m_instance == null)
            {
                // Lock the object
                lock (m_syncRoot)
                {
                    // Check to make sure its null
                    if (m_instance == null)
                    {
                        m_instance = new Singleton();
                    }
                }
            }
  
            // Return the non-null instance of Singleton
            return m_instance;
        }
    }
  } 
  </code></pre>
  
  <ol>
  <li>In what scenario would you opt to have eagerly initialized vs lazy initialized?</li>
  <li>Is the comment in the first example correct in saying that the initialization is thread safe? (I know it says it is, but it's the internet...)</li>
  </ol>