Boost - Threading several processes over several sessions - c++

Question

I am currently running into several problems while threading a couple different processes with boost. I am fairly new to threading so bear with me. Hopefully the formatting is good enough as well.
I have two threads defined.
boost::thread m_thread1;
boost::thread m_thread2;
Associated with these threads are three futures and two packaged_tasks
boost::packaged_task<bool> ptaskBool;
boost::packaged_task<double> ptaskDouble;
boost::unique_future<bool> futureBool;
boost::unique_future<double> futureDouble1;
boost::unique_future<double> futureDouble2;
Both of these threads are defined inside a while loop
while(running)
{
//some code
if(!thread1running)
{
ptaskBool = boost::packaged_task<bool>(boost::bind(/*some objects function*/));
futureBool = ptaskBool.get_future();
m_thread1 = boost::thread(boost::move(ptaskBool));
thread1running = true;
}
if(!thread2running && initial)
{
ptaskDouble = boost::packaged_task<bool>(boost::bind(/*some objects function*/));
futureDouble = ptaskDouble.get_future();
m_thread2 = boost::thread(boost::move(ptaskDouble));
thread2running = true;
}
else if(!thread2running)
{
ptaskDouble = boost::packaged_task<bool>(boost::bind(/*some different function*/));
futureDouble2 = ptaskDouble.get_future();
m_thread2 = boost::thread(boost::move(ptaskDouble));
initial = true;
thread2running = true;
}
This is a simplification of what I have but it is very similar. The next code I have is for the futures.
if(futureBool.is_ready())
{
m_bool = futureBool.get();
thread1running = false;
}
if(futureDouble.is_ready())
{
m_double = futureDouble.get();
std::cout << "Result: " << m_double << std::endl;
thread2running = false;
//have tried several things like a join here to no avail
}
if(futureDouble2.is_ready())
{
m_double = futureDouble2.get();
std::cout << "Result: " << m_double << std::endl;
thread2running = false;
}
}//end while
What I meant by sessions in the title is that there is some session handling in the background to do with telling the threads when and when not to be created.
There is other code that does some processing and flag checking but it is not relevant to my question. I am clearly misunderstanding something that is going on. The first time each thread is run, they complete their tasks. The second time the program just crashes.
I have had luck with making each thread variable a pointer and defining a new thread every time instead of redefining each thread. This worked but I was unable to delete each thread after completion. What am I not understanding here? What is the thread actually doing after the function returns a result?

Answer 1

auto_ptr is a good way to ensure your threads will be deleted at the end. Also is unique_ptr from C++11.
According to: http://www.cplusplus.com
Note: This class template (auto_ptr) is deprecated as of C++11. unique_ptr is a new facility with a similar functionality, but with improved security (no fake copy assignments), added features (deleters) and support for arrays. See unique_ptr for additional information.
See Using auto_ptr Effectively for examples using auto_ptr.