CareerCup

Double-checked locking can actually be incorrect, and is thus often considered an anti-pattern. Find the article on it on Wikipedia.

enums are implicitly thread safe as provided by VM in java, so this is the best way to define singleton.

Just use non-lazy load version:
class MyClass
{
private static MyClass _instance = new MyClass();
public MyClass GetInstance() {return _instance;}
}

#ifndef SINGLETON_HPP
#define SINGLETON_HPP

#ifdef __GNUC__
#define HAS_THREAD_SAFE_STATICS 1
#endif

#if defined _MSC_VER
#include <intrin.h>
inline void MemoryWriteBarrier() { _WriteBarrier(); }
#elif __GNUC__
#if defined __i386__ || defined __x86_64__
inline void MemoryWriteBarrier() { __asm__ __volatile__("sfence" ::: "memory");
    }
#else
#endif

#ifdef HAS_THREAD_SAFE_STATICS

template <class T>
class SingletonBase
{
private:
    SingletonBase(const SingletonBase&);
    void operator=(const SingletonBase&);

protected:
    SingletonBase() {}
    ~SingletonBase() {}

public:
    static T& Instance()
    {
        static T instance;
        return instance;
    }

};

#else

template <typename T>
class SingletonBase
{
private:
    SingletonBase(const SingletonBase&);
    void operator=(const SingletonBase&);

protected:
    SingletonBase() {}
    ~SingletonBase() {}

public:
    static T& Instance()
    {
        if (!m_instance)
        {
            ScopedLocker<Mutex> lock(m_lock);
            if (!m_instance)
            {
                T* p = new T();
                MemoryWriteBarrier();
                m_instance = p;
                atexit(Destroy);
            }
        }
        return *m_instance;
    }
private:
    static void Destroy()
    {
        if (m_instance)
        {
            delete m_instance;
            m_instance = NULL;
        }
    }

private:
    static Mutex m_lock;
    static T* volatile m_instance;
};

template <typename T>
Mutex SingletonBase<T>::m_lock;

template <typename T>
T* volatile SingletonBase<T>::m_instance;

#endif // HAS_THREAD_SAFE_STATICS

template <typename T>
class Singleton : public SingletonBase<T>
{
};

#endif // SINGLETON_HPP

try using the following code for singleton pattern that is other than double checking method
i,e
public static INSTANCE=new ClassName();// only one instance is created which and will be shared among all the classes

IODH:
class Singleton {
private Singleton(){ }

private static final Holder{
private static final Singleton instance = new Singleton();
}
public static final Singleton getInstance(){
return Singleton.Holder.instance;
}
}

Class Singleton{
int a;
int b;
...
}Singleton;
Use Singleton as object where ever you want to use, it will not all you to create a object as Singletion obj; as Singleton itself is an object. It also allows static vars like Singleton::a. Not sure if there any new compilers not supporting this, but I tested this in spro 3.4.

In Java, simplest way to create singletion is using Enum.

public enum Singleton
          {
                     INSTANCE;
          }

class Singelton
{
private:
static Singelton s_objSingelton;

protected:
Singelton()
~Singelton()

public:
static Singelton GetInstance()
{
return s_objSingelton;
}

};

class Singleton{
 private static Singleton instance;
 private Singleton(){
 }
 public static Singleton getInstance(){
  if(Singleton.instance == null){
   Singleton.instance = new Singleton();
  }
  return (Singleton.instance == null)? (Singleton.instance = new Singleton()) : Singleton.instance; 
 }
}

public sealed class Singleton
{
    private static readonly Lazy<Singleton> lazySingleton =
        new Lazy<Singleton>(() => new Singleton());
    
    public static Singleton Instance { get { return lazySingleton .Value; } }

    private Singleton()
    {
    }
}