如何安全地删除析构函数中的线程指针？

Question

Say, I have a C++ class including a thread pointer as a member variable. The thread keeps running until the program exits. If I delete the pointer in the destructor, it seems that the thread has not yet finished at that moment? What is the best practice to manage this or any tricks?

Sample code:

class Car {
public:
    Car();
    ~Car();
private:
    boost::thread *m_runningThreadPtr;
};


Car::Car() {
    m_runningThreadPtr = new boost::thread();
}

Car::~Car() {
    delete m_runningThreadPtr;    // The thread should be still running now. 
                                  // Problematic if it was deleted here?
}

Answer 1

By default the destructor will call terminate() to kill the thread if it's still running, whether this is safe or not depends on what the thread is doing at the time. You can call join() before deleting it if you want to wait for the thread to finish, and use some sort of synchronization system (even just a global flag) that tells the thread to quit.

Answer 2

It depends on what kind of behavior you're looking for.

If you want to delete the object, and have it stop its owned thread and then delete its thread object, then you should have a stop flag which your thread checks from time to time. In the destructor, you'd set the stop flag, and then call join() on your thread. Once it returns, you can safely delete the pointer.

If, on the other hand, you want to delete the object and have the thread go on its own until it finishes, then you need a more clever mechanism, like at the end of your thread function, posting to the main thread of your application a callback that calls join() on your thread and then delete s it. For that, of course, you'll need to have in your thread function a pointer to your thread object.

EDIT In the case of boost::thread , it simply detaches in its destructor, so for the second option you can safely delete it when you're done. It's important to note, however, that this won't work with std::thread 's destructor, which will terminate your program in such a case. But then you can also manually call detach() and then delete . So you really have to look at the API you're using.

Answer 3

Don't delete it. Have the thread delete itself when done.

Answer 4

Your program is done when there's no more code to run. Are your threads still running code? Then why do you think your program is done?

So, it's reasonable to assume your threads are i fact done. That means you can call .join() on the thread, after which it is OK to call delete .