Question

I am trying to write a class that would run a thread upon its object creation and stop the thread once the object gets deleted.

class MyThread : public boost::thread {

public:

    MyThread() : bAlive(true) { 
        boost::thread(&MyThread::ThreadFunction,this);
    }

    ~MyThread() {
        {
            boost::unique_lock<boost::mutex> lock(Mutex);
            bAlive=false;
        }
        ConditionVariable.notify_one();
        join();
    }

private:

    volatile bool bAlive;
    boost::mutex Mutex;
    boost::condition_variable ConditionVariable;

    void ThreadFunction() {
        boost::unique_lock<boost::mutex> lock(Mutex);
        while(bAlive) {
            ConditionVariable.timed_wait(lock,boost::get_system_time()+ boost::posix_time::milliseconds(MAX_IDLE));

            /*******************************************
            * Here goes some code executed by a thread * 
            *******************************************/

        }
    }

};

Theoretically, I want to wake the thread up instantly as soon as it needs to be finished, so I had to use timed_wait instead of Sleep.
This works fine until I try to delete an object of this class. In most cases, it deletes normally, but occasionally it causes an error either in condition_variable.hpp, thread_primitives.hpp or crtexe.c. Sometimes I am notified that “Free Heap block 3da7a8 modified at 3da804 after it was freed”, and sometimes I’m not. And yes, I’m aware of the spurious wakeups of timed_wait, in this case it’s not critical.
Can you please point me to the source of my problem? What am I doing wrong?

Answer 1

I see what you’re trying to do but it doesn’t work as you expect:

MyThread foo;

default constructs a boost::thread (because MyThread is derived from boost::thread).
The default constructor creates a boost::thread instance that refers to Not-a-Thread.

MyThread() {
    boost::thread(&MyThread::ThreadFunction,this);
}

is actually creating a different thread and you’re ignoring the returned object (the valid thread).

~MyThread() {
    // ...
    join();
}

is then trying to join the default constructed thread (which throws an exception inside the destructor) and you never join the thread that actually does the work.

---

First of all, don’t derive from boost::thread. Create a member variable instead:

class MyThread {
// ...
private:
    // ...
    boost::thread _thread;
};

In the constructor, create and assign a thread to that member variable:

MyThread() {
    _thread = boost::thread(&MyThread::ThreadFunction,this);
}

and call its join() in your destructor.

~MyThread() {
    // ...
    _thread.join();
}

That should fix your problem.

---

However, if you simply want to exit the thread when your object is destroyed (and don’t have to wake it up while its running), you can use a different approach. Remove the mutex and the condition variable and use interrupt instead. This will cause sleep() to throw an exception so you have to catch it:

void ThreadFunction() {
    try {
        for(;;) {
            boost::this_thread::sleep(boost::posix_time::milliseconds(MAX_IDLE));
            // Here goes some code executed by a thread
        }
    } catch( const boost::thread_interrupted& e ) {
        // ignore exception: thread interrupted, exit function
    }
}

This will instantly exit the ThreadFunction when the thread is interrupted. If you don’t need the thread to sleep every cycle, you can replace it with boost::this_thread::interruption_point(). This will just throw an exception if the thread is interrupted.

Now you can simply interrupt the thread in the destructor:

MyThread::~MyThread() {
    _thread.interrupt();
    _thread.join();
}