CODEWITHSUNDEEP
c++destructorboost-thread
user1814683
user1814683

Reputation: 33

Deleting boost::thread descendant

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?

Upvotes: 3

Views: 209

Answers (1)

Anonymous Coward
Anonymous Coward

Reputation: 6226

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();
}

Upvotes: 1

Related Questions