Question

I have a class that has a Start method to start a thread that executes the virtual ThreadFunction at a predefined interval. The Stop method sets an event and waits until the the thread terminates (by a WaitForSingleObject on the thread handle).

In the destructor of MyThread, I call the Stop method. So whenever I delete the instance, I’m sure the thread is stopped before the delete returns.

class MyThread
{
    void Start();
    void Stop();
    ~MyThread() { Stop(); }
    virtual VOID ThreadFunction() { }
};

Next I have a class that derives from MyThread:

class A : MyThread
{
    virtual VOID ThreadFunction()
    {
        for (int i = 0; i < 1000; i++)
            TestFunction();
    }

    void TestFunction() { // Do something }
};

Consider this code:

A a = new A();
a->Start();
delete a;

The problem is that delete a will first call the destructor of A before it will call the destructor of MyThread right? So if the thread was executing the for-loop in the ThreadFunction, the Stop method will be called after a has been destructed. This can lead to an access violation, when ThreadFunction calls TestFunction on a destructed instance.

A solution would be to add a destructor to class A that calls the Stop method, like this:

class A : MyThread
{
    ~A()
   {
       Stop();
   }
}

But because I have a more complex class hiërarchy, that involves multiple inherited classes, this would mean I have to call the Stop method in each destructor, which would result in the Stop method being called plenty of times for only one instance that needs to be deleted.

Is there any other way to tackle this problem?

Answer 1

As Rolle and R. Martinho Fernandes suggested, I needed to separate the two concerns.

class MyThread should not start or stop itself as its responsibility should be limited to the code it executes and not to the lifetime of the thread.

So the solution was to stop the thread from an other class (the same class that started the thread) which is responsible for the lifetime of the thread.