Re: [boost] Singleton Review

6 May 2005

      Jonathan Turkanis wrote:
...
It only takes a few minutes to figure out how to use Boost.Threads. I suggest
you implement and test a lock policy using Boost.Threads and make it available
to reviewers.
Alright, I have completed a sample program, which is attached.  The 
example has been added to the download package as well.  Hopefully this 
alleviates some concerns.

Tom Brinkman wrote:
...
Was the "singleton" library tested on GCC.  
I'm getting many compiler errors on 3.34.
The newly uploaded package should fix most of those errors, please let 
me know if any still need to be corrected.

-Jason

#include <iostream>
#include <boost/singleton.hpp>
#include <boost/thread/recursive_mutex.hpp>
#include <boost/thread/thread.hpp>

using namespace boost;
using namespace boost::singleton;

// singleton to hold the mutex
class mutex_holder : public basic_singleton < mutex_holder >
{
private:
    // make sure singleton is created before main
    // (assumes no secondary threads are created until main)
    static mutex_holder self;

    // the mutex to lock (must be recursive with
    // current singleton implementation)
    recursive_mutex mutex_;

public:
    recursive_mutex & get_mutex (  )
    {
        return mutex_;
    }
};

// our custom locking policy
class shared_singleton_lock : recursive_mutex::scoped_lock
{
public:
    shared_singleton_lock (  ) :
      recursive_mutex::scoped_lock ( mutex_holder::pointer (  )->get_mutex (  ) )
    {
    }

    // the following are needed because locks need to be able to be copied

    shared_singleton_lock ( const shared_singleton_lock & rhs ) :
    recursive_mutex::scoped_lock ( mutex_holder::pointer (  )->get_mutex (  ) )
    {
    }

    shared_singleton_lock & operator = ( const shared_singleton_lock & rhs )
    {
    }
};

// singleton which uses the locking policy
class shared_singleton :
    public singleton_ex
    <
        shared_singleton,
        lifo_lifetime_ex
        <
            instant_creation,
            create_statically,
            shared_singleton_lock
        >
    >
{
private:
    // depends upon mutex_holder
    mutex_holder::pointer holder_ptr;
    int val;

protected:
    shared_singleton (  ) : val ( 0 )
    {
    }

public:
    // Put something in here designed to fail if two
    // threads access the function at the same time
    void DoSomething (  )
    {
        std::cout << "Entering function, val == " << val << "\n";
        val = val + 1;
        std::cout << "Exiting function, val == " << val << "\n";
    }
};

void test (  )
{
    shared_singleton::pointer ptr;

    // we have 6 threads, so if all goes well
    // the last thing printed should be 6000
    for ( int i = 0; i < 1000; ++i )
    {
        ptr->DoSomething (  );
    }
}

int main (  )
{
    thread t1 ( &test );
    thread t2 ( &test );
    thread t3 ( &test );
    thread t4 ( &test );
    thread t5 ( &test );
    thread t6 ( &test );

    // must join all threads so that program does not end
    // while threads are executing ( this would kill the
    // singleton instances and probably result in a crash )
    t1.join (  );
    t2.join (  );
    t3.join (  );
    t4.join (  );
    t5.join (  );
    t6.join (  );
    return 0;
}

Re: [boost] Singleton Review

Jason Hise