Re: std::thread...too little, too late?
On 19/12/2014 22:14, Chris Vine wrote:
On Fri, 19 Dec 2014 13:53:26 +0000
Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> wrote:
[snip]
I think it makes perfect sense to derive from std::thread so there is
nothing intrinsically wrong with having a virtual "thread started"
method.
So, what polymorphic behaviour do you think this "run" method described
by the OP might exhibit? A run method should just start the thread.
It is horrible 1990's over-OO design to use polymorphism just to
represent the function to be executed. All you need do is apply the
thread function/lambda/callable object passed to the thread object to
its arguments (if any), which is what std::thread does.
That is like saying "It is horrible 1990's over-OO design to use virtual
functions." which is of course nonsense.
You seem to be ignoring my other reply: my virtual "task()" function is
actually in my thread class which *contains* a boost::thread object.
My start() method:
void thread::start()
{
lock();
if (started())
{
unlock();
throw thread_already_started();
}
try
{
iState = Starting;
if (!iUsingExistingThread)
{
thread_object_pointer newThread(new
boost::thread(boost::bind(&thread::entry_point, this)));
iThreadObject = newThread;
unlock();
}
else
{
unlock();
entry_point();
}
}
catch(const std::exception& aException)
{
iState = Error;
unlock();
std::cerr << std::string("Error starting thread due to exception
being thrown (") + aException.what() + ")." << std::endl;
throw;
}
catch(...)
{
iState = Error;
unlock();
std::cerr << std::string("Error starting thread due to exception of
unknown type being thrown.") << std::endl;
throw;
}
}
My entry_point() method which calls the pure virtual task() function:
void thread::entry_point()
{
lock();
iState = Started;
iId = boost::this_thread::get_id();
unlock();
try
{
task(); /* This is the pure virtual that requires overriding */
if (!iUsingExistingThread)
{
lock();
if (iState == Started)
iState = Finished;
unlock();
}
}
catch(const std::exception& aException)
{
std::cerr << std::string("Thread terminating due to an uncaught
exception was being thrown (") + aException.what() + ")." << std::endl;
throw;
}
catch(...)
{
std::cerr << "Thread terminating due to an uncaught exception of
unknown type being thrown." << std::endl;
throw;
}
}
What we are basically talking about here is the /template method
pattern/ and there is nothing wrong with it; it certainly is *not*
"horrible 1990's over-OO design"
/Flibble