[Boost-users] [BOOST THREAD] Threads Spawning Unexpectedly

Subject: [Boost-users] [BOOST THREAD] Threads Spawning Unexpectedly
From: Terrimane Pritchett (shon.pritchett_at_[hidden])
Date: 2009-04-26 19:52:11

Hello,

I have taken interest in using Boost Threads in my project.  I have a
strange issue that I am trying to debug.

I spawn N boost::thread instances because I know exactly how many I need.
My program crashes after a time on a boost::bad_lexical_cast exception.  I
have placed a wrapper around boost::lexical_cast which uses a
boost::recursive_mutex and boost::lock_guard combination to prevent multiple
threads from calling boost::lexical_cast at the same time.

Still, my project invariably chokes on boost::bad_lexical_cast being thrown
when I can verify the cast should work i.e. everything works as expected in
my single threaded implementation.

My real cause for alarm is this....when I act to debug my project I always
discover there are more active boost::thread instances than I have
explicitly created.  I only create boost::thread instances in one location.

I have perused the documentation but as of yet cannot find an explanation
for this behavior.  My assumption is that unless I explicitly instantiate a
boost::thread it should not exist.  However, I want to ask if this is indeed
the case?  If not, how so and what is the rationale behind this behavior?

Here is what my code more or less looks like - this is all I do with
boost::threads currently - how are more than N boost::threads spawning where
N is the number of elements in an arbitrary stl container which itself is
not allowed to change in size?

typedef boost::shared_ptr<boost::thread> THREADHANDLE;
typedef std::vector<THREADHANDLE> THREADHANDLECONTAINER;
THREADHANDLECONTAINER workerThreads;
workerThreads.reserve(some_container.size());

...

workerThreads.push_back(
        THREADHANDLE(new THREADHANDLE::element_type(
                Callable,
                arg1,
                boost::ref(arg2));

...

BOOST_FOREACH(const THREADHANDLE &workerThread,workerThreads)
{
        workerThread->join();
}//end loop

------------------------------------------

Here is my attempt at using boost::lexical_cast in a generic thread safe
manner.  I am expecting exactly one thread my call boost::lexical_cast at a
time with this wrapper yet my application blows up solely on
boost::bad_lexical_cast whenever I introduce Boost Threads.

Am I missing the elephant in the room somehow?

//LexicalCaster.h
#include <boost/thread.hpp>

struct LexicalCaster
{
        template<typename TargetType,typename SourceType>
        inline static TargetType LexicalCast(const SourceType &source);
private:
        static boost::recursive_mutex& GetMutex();
        static int& GetCount();
};

//LexicalCaster.cpp
#include "LexicalCast.h"

boost::recursive_mutex _mtx;
int count(0);                           //here for debugging purposes

boost::recursive_mutex& LexicalCaster::GetMutex()
{
        return _mtx;
}

int& LexicalCaster::GetCount()
{
        return count;
}

//LexicalCaster.inl
#include <boost/lexical_cast.hpp>

template<typename TargetType,typename SourceType>
TargetType LexicalCaster::LexicalCast(const SourceType &source)
{
        boost::lock_guard<boost::recursive_mutex>
guardian(LexicalCaster::GetMutex());

        std::cerr<<"Count: "<<LexicalCaster::GetCount()++<<std::endl;
//the count will display sequentially if only

//one thread of execution has access at a time

        return boost::lexical_cast<TargetType>(source);