Re: boost::thread
On Aug 1, 7:20 pm, Christopher <cp...@austin.rr.com> wrote:
I am trying to make a thread object, so I can later have
better control of threads and the resources they are using.
So, I started wrapping up a boost::thread.
//---------------------------------------------------------------------------------------------------------------------------------------------
// BaseThread.h
#include <boost/thread/thread.hpp>
//------------------------------------------------------------------------------
/// \brief Thread object that performs a task that is to run once (non- looped)
/// \detail Derive from this class and implement the Work method to define the
/// work this thread is to perform
This is *not* a good way to go about it. The class containing
the code to be executed should be separate from the thread
object itself. (You might want to pass it as an argument to the
constructor of the thread object, however.)
class BaseThread
{
public:
BaseThread();
/// \brief Deconstructor
/// \detail It is required that a derived class make a call to
thread_.join()
/// in its deconstructor
virtual ~BaseThread();
virtual void Start();
virtual int Work() = 0;
protected:
void Run();
boost::thread thread_;
};
//---------------------------------------------------------------------------------------------------------------------------------------------
// BaseThread.cpp
#include "BaseThread.h"
//------------------------------------------------------------------------------
BaseThread::BaseThread()
{
}
//------------------------------------------------------------------------------
BaseThread::~BaseThread()
{
// Wait for the thread to complete
thread_.join();
I'm afraid I don't like this. I don't like the idea of a class
waiting for anything in its destructor; it can cause the code to
hang in unexpected places.
If the threads are to be joinable, then it is the client who
should do the joining, not the thread class. (But threads don't
have to be joinable.)
// DEBUG - Does join wait?
int x = 1;
}
//------------------------------------------------------------------------------
void BaseThread::Start()
{
boost::thread newThread(boost::bind(&BaseThread::Run, this));
thread_.swap(newThread);
}
//------------------------------------------------------------------------------
void BaseThread::Run()
{
this->Work();
}
I am kind of winging it here just going off of the boost documentation
and guessing at what I should be doing.
It isn't. Although Boost doesn't make the distinction it really
should. Threads may be joinable or not. In the case of Boost,
if you call the destructor of a boost::thread before joining,
the thread will be detached, and will go along on its merry way.
This may or may not be what you wanted; if the thread is
supposed to be joinable, and an exception causes the destructor
to be called (and the context where the join was to take place)
to disappear, you really want to somehow abort the thread. If
the thread operates more in fire and forget mode (e.g. a thread
started from the GNI thread, in response to a GUI event), then
you don't want it to be joinable (and doing a join from the
context were the thread was started defeats the purpose of
starting it), there's really nothing for the thread object to
do, and no point in even having it. Just drop the boost::thread
object as soon as the thread has been started.
--
James Kanze