mirror of
https://gitee.com/acl-dev/acl.git
synced 2024-12-14 17:00:52 +08:00
209 lines
5.5 KiB
C++
209 lines
5.5 KiB
C++
#pragma once
|
||
#include "../acl_cpp_define.hpp"
|
||
#include <assert.h>
|
||
#include "noncopyable.hpp"
|
||
|
||
// singleton.hpp
|
||
//
|
||
// Copyright David Abrahams 2006. Original version
|
||
//
|
||
// Copyright Robert Ramey 2007. Changes made to permit
|
||
// application throughout the serialization library.
|
||
//
|
||
// Distributed under the Boost
|
||
// Software License, Version 1.0. (See accompanying
|
||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||
//
|
||
// The intention here is to define a template which will convert
|
||
// any class into a singleton with the following features:
|
||
//
|
||
// a) initialized before first use.
|
||
// b) thread-safe for const access to the class
|
||
// c) non-locking
|
||
//
|
||
// In order to do this,
|
||
// a) Initialize dynamically when used.
|
||
// b) Require that all singletons be initialized before main
|
||
// is called or any entry point into the shared library is invoked.
|
||
// This guarentees no race condition for initialization.
|
||
// In debug mode, we assert that no non-const functions are called
|
||
// after main is invoked.
|
||
|
||
namespace acl {
|
||
|
||
#if defined(_WIN32) || defined(_WIN64)
|
||
# pragma warning(push)
|
||
# pragma warning(disable : 4511 4512)
|
||
#endif
|
||
|
||
//////////////////////////////////////////////////////////////////////
|
||
// Provides a dynamically-initialized (singleton) instance of T in a
|
||
// way that avoids LNK1179 on vc6. See http://tinyurl.com/ljdp8 or
|
||
// http://lists.boost.org/Archives/boost/2006/05/105286.php for
|
||
// details.
|
||
//
|
||
|
||
// singletons created by this code are guarenteed to be unique
|
||
// within the executable or shared library which creates them.
|
||
// This is sufficient and in fact ideal for the serialization library.
|
||
// The singleton is created when the module is loaded and destroyed
|
||
// when the module is unloaded.
|
||
|
||
// This base class has two functions.
|
||
|
||
// First it provides a module handle for each singleton indicating
|
||
// the executable or shared library in which it was created. This
|
||
// turns out to be necessary and sufficient to implement the tables
|
||
// used by serialization library.
|
||
|
||
// Second, it provides a mechanism to detect when a non-const function
|
||
// is called after initialization.
|
||
|
||
// make a singleton to lock/unlock all singletons for alteration.
|
||
// The intent is that all singletons created/used by this code
|
||
// are to be initialized before main is called. A test program
|
||
// can lock all the singletons when main is entereed. This any
|
||
// attempt to retieve a mutable instances while locked will
|
||
// generate a assertion if compiled for debug.
|
||
|
||
class singleton_module : public noncopyable
|
||
{
|
||
public:
|
||
static void lock()
|
||
{
|
||
get_lock() = true;
|
||
}
|
||
|
||
static void unlock()
|
||
{
|
||
get_lock() = false;
|
||
}
|
||
|
||
static bool is_locked() {
|
||
return get_lock();
|
||
}
|
||
private:
|
||
static bool& get_lock()
|
||
{
|
||
static bool lock_ = false;
|
||
return lock_;
|
||
}
|
||
};
|
||
|
||
template<class T>
|
||
class singleton_wrapper : public T
|
||
{
|
||
public:
|
||
static bool destroyed_;
|
||
~singleton_wrapper()
|
||
{
|
||
destroyed_ = true;
|
||
}
|
||
};
|
||
|
||
template<class T>
|
||
bool singleton_wrapper< T >::destroyed_ = false;
|
||
|
||
/**
|
||
* 单例模板类,用VC2010或GCC编译时,单例对象在 main 函数之前被执行,
|
||
* 所以它是线程安全的;但在 VC2003 编译成 release 版本时且打开了优化
|
||
* 开关,则有可能是线程不安全的,此时不能保证单例对象的构造函数在
|
||
* main 之前执行.
|
||
* 使用举例如下:
|
||
* class singleton_test : public acl::singleton<singlegon_test>
|
||
* {
|
||
* public:
|
||
* singleton_test() {}
|
||
* ~singleton_test() {}
|
||
* singleton_test& init() { return *this; }
|
||
* };
|
||
|
||
* int main()
|
||
* {
|
||
* singleton_test& test = singleton_test::get_instance();
|
||
* test.init();
|
||
* ...
|
||
* return 0;
|
||
* }
|
||
*/
|
||
template <class T>
|
||
class singleton : public singleton_module
|
||
{
|
||
public:
|
||
static T& get_instance()
|
||
{
|
||
static singleton_wrapper< T > t;
|
||
// refer to instance, causing it to be instantiated (and
|
||
// initialized at startup on working compilers)
|
||
assert(!singleton_wrapper< T >::destroyed_);
|
||
use(instance_);
|
||
return static_cast<T &>(t);
|
||
}
|
||
|
||
static bool is_destroyed()
|
||
{
|
||
return singleton_wrapper< T >::destroyed_;
|
||
}
|
||
|
||
private:
|
||
static T& instance_;
|
||
// include this to provoke instantiation at pre-execution time
|
||
static void use(T const &) {}
|
||
};
|
||
|
||
template<class T>
|
||
T& singleton< T >::instance_ = singleton< T >::get_instance();
|
||
|
||
//////////////////////////////////////////////////////////////////////////
|
||
|
||
/**
|
||
* 上面的实现在 VC2003 的 release 编译时如果打开了优化开关,则不能保证单例
|
||
* 的构造函数先于 main 执行,如果是在 VC2003 下编译单例程序且在多个线程下
|
||
* 都用单例对象时,建议使用如下的单例模板类,示例如下:
|
||
* class singleton_test
|
||
* {
|
||
* public:
|
||
* singleton_test() {}
|
||
* ~singleton_test() {}
|
||
* singleton_test& init() { return *this; }
|
||
* };
|
||
|
||
* int main()
|
||
* {
|
||
* singleton_test& test = acl::singleton2<singleton_test>::get_instance();
|
||
* test.init();
|
||
* ...
|
||
* return 0;
|
||
* }
|
||
*
|
||
*/
|
||
template <typename T>
|
||
struct singleton2
|
||
{
|
||
private:
|
||
struct object_creator
|
||
{
|
||
object_creator() { singleton2<T>::get_instance(); }
|
||
inline void do_nothing() const {};
|
||
};
|
||
static object_creator create_object;
|
||
|
||
public:
|
||
typedef T object_type;
|
||
static object_type & get_instance()
|
||
{
|
||
static object_type obj;
|
||
create_object.do_nothing();
|
||
return obj;
|
||
}
|
||
};
|
||
|
||
template <typename T>
|
||
typename singleton2<T>::object_creator singleton2<T>::create_object;
|
||
|
||
#if defined(_WIN32) || defined(_WIN64)
|
||
#pragma warning(pop)
|
||
#endif
|
||
|
||
} // namespace acl
|