Hi all.
I was faced with the requirement for a singleton class where the object
has to be constructed dynamically and where I wanted to assure that the
object is destructed automatically when no longer needed.
A solution using shared_ptr and weak_ptr immediately came to mind and
after a short google I found
http://lists.boost.org/boost-users/2002/10/2014.php.
However, if you have to assure that construction and destruction never
overlap if you have multiple (sequential) initializations/destructions
it gets a bit more complicated :)
Well. Here follows what I have come up with and it seems to work pretty
well.
Any comments welcome.
br,
Martin
Singleton using boost weak_ptr and shared_ptr
---------------------------------------------
Requirement: Singleton that is constructed on first use (not on process
start) and destroyed after the last "client-code" has finished with it.
Note: It is therefore possible that more that one Singleton instances
exist within a process's lifetime, BUT there must only be at most one
Object active at any given time (Construction must not run before
destruction has finished.
Starting point: http://lists.boost.org/boost-users/2002/10/2014.php
Problem of the simple solution: No protection against multiple
initialization and against simultaneous deletion and construction.
Solution: The construction and destruction of the singleton instance(s)
has to be protected additionally.
[CODE:dynamic_singleton.h]
#pragma once
//////////////////////////////////////////////////////////////////////
#include
#include
#include
//////////////////////////////////////////////////////////////////////
class dynamic_singleton : private boost::noncopyable
{
public:
typedef boost::shared_ptr shared_t;
static shared_t get_instance();
// Interface:
void example(int cookie);
// ...
private:
dynamic_singleton();
virtual ~dynamic_singleton();
struct impl;
typedef boost::scoped_ptr<impl> impl_t;
impl_t pimpl;
struct deleter;
friend struct deleter;
};
[/CODE]
[CODE:dynamic_singleton.cpp]
#include "dynamic_singleton.h"
#include
#include
#include
//////////////////////////////////////////////////////////////////////
#define MESG(msg) \
printf("%s\n", msg); \
/**/
//////////////////////////////////////////////////////////////////////
class atomic_bool : protected boost::noncopyable
{
public:
atomic_bool() : b_(false) {}
explicit atomic_bool(bool b) : b_(b) {}
inline operator bool() const {
boost::recursive_mutex::scoped_lock lock(sync_);
return b_;
}
inline bool operator=(bool b) {
boost::recursive_mutex::scoped_lock lock(sync_);
b_ = b;
return b_;
}
private:
bool b_;
mutable boost::recursive_mutex sync_;
};
//////////////////////////////////////////////////////////////////////
struct dynamic_singleton::impl : private boost::noncopyable
{
impl() {}
~impl() {}
static void start_construction()
{
boost::xtime spin_time;
spin_time.sec = 1;
while(the_object_exists) {
boost::thread::sleep(spin_time);
}
}
static void finish_construction()
{
assert(!the_object_exists);
the_object_exists = true;
}
static void finish_destruction()
{
assert(the_object_exists);
the_object_exists = false;
}
typedef boost::weak_ptr internal_shared_t;
static internal_shared_t the_object;
static boost::recursive_mutex sync_init;
static atomic_bool the_object_exists;
};
//////////////////////////////////////////////////////////////////////
dynamic_singleton::impl::internal_shared_t
dynamic_singleton::impl::the_object;
boost::recursive_mutex
dynamic_singleton::impl::sync_init;
atomic_bool
dynamic_singleton::impl::the_object_exists;
//////////////////////////////////////////////////////////////////////
struct dynamic_singleton::deleter
{
void operator() (dynamic_singleton* p)
{
assert(p);
delete p;
impl::finish_destruction();
}
};
//////////////////////////////////////////////////////////////////////
dynamic_singleton::shared_t dynamic_singleton::get_instance()
{
// Syncronise Initialization:
boost::recursive_mutex::scoped_lock lock(impl::sync_init);
MESG(__FUNCTION__);
// Acquire singleton pointer:
shared_t object_ptr = impl::the_object.lock();
if(!object_ptr.use_count()) {
impl::start_construction();
object_ptr.reset(new dynamic_singleton(), dynamic_singleton::deleter());
impl::the_object = object_ptr;
impl::finish_construction();
}
return object_ptr;
}
//////////////////////////////////////////////////////////////////////
dynamic_singleton::dynamic_singleton()
{
pimpl.reset(new impl());
MESG(__FUNCTION__);
// For example open a unique system or process global resource
printf(" >> Singleton opens the global resouce.\n");
}
//////////////////////////////////////////////////////////////////////
dynamic_singleton::~dynamic_singleton()
{
MESG(__FUNCTION__);
// For example close a unique system or process global resource
printf(" << Singleton closes the global resouce.\n");
}
//////////////////////////////////////////////////////////////////////
void dynamic_singleton::example(int cookie)
{
printf("%s(%d)\n", __FUNCTION__, cookie);
}
[/CODE]
[CODE:main.cpp]
#include "dynamic_singleton.h"
#include <iostream>
#include
struct singleton_user
{
explicit singleton_user(int num)
: num_(num)
{ }
void operator()()
{
using namespace std;
printf("%d uses singleton ...\n", num_);
dynamic_singleton::shared_t s = dynamic_singleton::get_instance();
s->example(num_);
}
int num_;
};
int main(int argc, char* argv[])
{
boost::thread t1( singleton_user(1) );
boost::thread t2( singleton_user(2) );
boost::thread t3( singleton_user(3) );
boost::thread t4( singleton_user(4) );
boost::thread t5( singleton_user(5) );
t1.join();
t2.join();
t3.join();
t4.join();
t5.join();
return 0;
}
[/CODE]
