6장, 싱글턴(Singleton)의 구현 - 6.2 싱글턴 패턴을 정책 기반(policy-based) 클래스로 디자인하기 - 쓰레드 정책 추가

이 포스트의 목적

• 쓰레드 정책 추가한 버전을 기록하기 위해
  

이 포스트의 준비물

• Firefox 4.0 b7
  
• msvc 10
  
• gvim

참조 링크

• http://sourceforge.net/projects/loki-lib/ - Loki library
  

참조 서적

• 안드레 알렉산드레스쿠 저. Modern C++ Design. 이기형 역.
  Addiston-Wesley. 인포북. 초판 2003.07.30. page(248 ~ 259)

내용

맛보기 코드 - 라이브러리
#pragma once // creation policy // template <typename T> class create_using_new { public: static T* create() { return new T(); } static void destroy(T *p) { delete p; } }; template <typename T> class create_using_static { public: static T* create() { static static_memory t; return new (&t) T; } static void destroy(T *p) { p->~T(); } private: union static_memory { char temp_[sizeof(T)]; }; }; // life time policy // typedef void (*atexit_pfn_t)(); template <typename T> class default_life_time { public: static void on_dead_reference() { throw std::logic_error("dead reference"); } static void schedule_destruction(T *, atexit_pfn_t pfn) { std::atexit(pfn); } }; template <typename T> class phoenix_life_time { public: static void on_dead_reference() { //destroyed_once_ = true; } static void schedule_destruction(T *, atexit_pfn_t pfn) { //if (false == destroyed_once_) std::atexit(pfn); } private: //static bool destroyed_once_; }; //template <typename T> bool phoenix_life_time<T>::destroyed_once_ = false; template <typename T, typename MT> class single_thread { public: // dummy locker for single thread struct locker { locker() {} explicit locker(const single_thread&){} explicit locker(const single_thread*){} }; typedef T* volatile_ptr_t; }; template <typename T, typename MT> class multi_thread { public: typedef T* volatile_ptr_t; public: struct locker { ~locker() { mt_.un_lock(); } locker() { mt_.lock(); } }; private: static MT mt_; }; template <typename T, typename MT> MT multi_thread<T, MT>::mt_;
#pragma once // for windows #if defined(WIN32) || defined(WIN64) #include <windows.h> class default_mutex { private: default_mutex(const default_mutex&); default_mutex& operator=(const default_mutex&); public: ~default_mutex() { DeleteCriticalSection(&critical_section_); } default_mutex() { InitializeCriticalSectionAndSpinCount(&critical_section_, 0x80000400); } void lock() { EnterCriticalSection(&critical_section_); } void un_lock() { LeaveCriticalSection(&critical_section_); } private: CRITICAL_SECTION critical_section_; }; #endif
#pragma once #include "singleton_policy.hpp" #include "default_mutex_lock.hpp" template <typename T, template <class> class creation_policy = create_using_new, template <class> class life_time_policy = default_life_time, template <class, class> class thread_policy = single_thread, typename MUTEX_T = default_mutex > class singleton_holder { private: ~singleton_holder() { } singleton_holder() { } public: static void destroy_singleton() { creation_policy<T>::destroy(p_instance_); p_instance_ = 0; destoryed_ = true; } static T& instance() { if (0 == p_instance_) { typename thread_policy<T, MUTEX_T>::locker guard; (void)guard; if (0 == p_instance_) { if (true == destoryed_) { default_life_time<T>::on_dead_reference(); destoryed_ = false; } p_instance_ = creation_policy<T>::create(); life_time_policy<T>::schedule_destruction(p_instance_, destroy_singleton); } } return *p_instance_; } private: typedef typename thread_policy<T, MUTEX_T>::volatile_ptr_t instance_ptr_t; static instance_ptr_t p_instance_; static bool destoryed_; }; template <typename T, template <class> class C, template <class> class L, template <class, class> class TM, typename MT > typename singleton_holder<T, C, L, TM, MT>::instance_ptr_t singleton_holder<T, C, L, TM, MT>::p_instance_ = 0; template <typename T, template <class> class C, template <class> class L, template <class, class> class TM, typename MT > bool singleton_holder<T, C, L, TM, MT>::destoryed_ = false;

맛보기 코드 - 사용법
#include <iostream> #include "singleton_holder.hpp" int main(int argc, char* argv[]) { singleton_holder<int>::instance() = 3; singleton_holder<int>::instance() = 4; singleton_holder<int, create_using_static>::instance() = 6; singleton_holder<int, create_using_static>::instance() = 7; singleton_holder<int, create_using_static, phoenix_life_time>::instance() = 8; singleton_holder<int, create_using_static, phoenix_life_time>::instance() = 9; singleton_holder<int, create_using_static, phoenix_life_time, multi_thread>::instance() = 10; return 0; }

여담

• 음... 더 고치고 싶으나. 어딜 모르겠다. 실제로 써보면서 고칠것 있으면 고쳐서 써야겠다.
  
• policy-based design 으로 하는 방법은 어떻게 해야 할지 감이 온다.그래픽 엔진에 써먹으면 재미있을 듯 하다.
  
  
• 다음 공부할 내용은 스마트 포인터 인데, 이건 넘겨도 된다고 생각하므로, 객체 팩토리로 넘어간다.