线程安全的单例模式

pthread版本

template<typename T>
class Singleton : boost::noncopyable
{
 public:
  static T& instance()
  {
    pthread_once(&ponce_, &Singleton::init);
    return *value_;
  }

 private:
  Singleton();
  ~Singleton();

  static void init()
  {
    value_ = new T();
    ::atexit(destroy);
  }

  static void destroy()
  {
    delete value_;
  }

 private:
  static pthread_once_t ponce_;
  static T*             value_;
};

template<typename T>
pthread_once_t Singleton<T>::ponce_ = PTHREAD_ONCE_INIT;

template<typename T>
T* Singleton<T>::value_ = NULL;

}

C++11版本

template <class T>
class Singleton
{
public:
    static T* instance()
    {
        std::call_once(single_created,init);
        return  single;
    }
    static void destroy()
    {
        delete single;
        single = nullptr;
    }
private:
    Singleton(){}
    static void  init()
    {
        single = new T();
        std::atexit(destroy);
    }
    static T* single;
    static std::once_flag single_created;
};
template<class T> 
T* Singleton<T>::single = nullptr;
template<class T> 
std::once_flag Singleton<T>::single_created;