prevent derived class from being destroyed

Question

I have a base class IRunnable with a protected constructor, so that no instances of the base class can be created. The class has a pure virtual method run(), which has to be implemented by derived classes. I am passing pointers of IRunnable * to some kind of java-like Executor, which controls a number of threads, and assigns those Runnables to them. My Problem is, when such a IRunnable * pointer, pointing to an object of a derived class of IRunnable, which lies on a stack of another Thread, is assigned to a worker Thread, i can not be sure, that the derived Object is not destroyed while the worker thread is still using it, since the thread that has the object on its thread could leave the scope where the object was created. For Example:

int main(void)
{
    CExecutor myExecutor(...); 
    for (UInt32 i = 0; i < 2; i++)
    {
        derivedRunnable myRunnable1; //will be destroyed after each loop iteration
        myExecutor.submit(myRunnable1);
    }
}

class derivedRunnable : public IRunnable
{
public:
    derivedRunnable(const char * name = NULL) : IRunnable(name) {}
    ~derivedRunnable() {}
    void run(void)
    {
        for (UInt32 i = 0; i < 100; i++)
        {
            char name [256] = {"\0"};

            pthread_getname_np(pthread_self(), name, 255);
            printf("%s in step %d\n", name, i);
        }
        fflush(stdout);
    }
};

I implemented a reference count in the base class IRunnable, and I do a blocking call in the destructor that will only come back when the last thread using it unregisters with it. The problem is, the destructor of the derived class get's called first, so the object will be partially destructed before base class destructed with the blocking call is called. In the above example, i get the following runtime error:
pure virtual method called
terminate called without an active exception If I insert a usleep of some usec after the .submit() call, it will work, because the thread will be finished with the runnable, before it gets destroyed

class IRunnable
{
    friend class CThread;
    friend class CExecutor;
private:
    CMutex mutx;
    CBinarySemaphore sem;
    UInt32 userCount;
    [...]
    virtual void run(void) = 0;
    IRunnable(const IRunnable & rhs); //deny
    IRunnable & operator= (const IRunnable & rhs); //deny

    void registerUser(void)
    {
        mutx.take(true);
        if (0 == userCount++)
            sem.take(true);
        mutx.give();
    }

    void unregisterUser(void)
    {
        mutx.take(true);
        if (0 == --userCount)
            sem.give();
        mutx.give();
    }

protected:
    IRunnable(const char * n = NULL)
    :mutx(true,false)
    ,sem(true,false)
    ,userCount(0)
    {
        setName(n);
    }

    ~IRunnable()
    {
        sem.take(true);
    }
    [...]

What could I do?

Answer 1

If you block in the destructor, then your submit loop won't be asynchronous, which is the point of multithreading. The lifetime has to continue past the allocation scope. To do this, you should allocate your IRunnable objects dynamically, and let your Executor take ownership. The Executor will be in charge of deleting it when the job is complete.

Even better, use shared pointers for this interface. That way the calling thread can still refer to the object (for instance to check completion). The last thread finished will delete the object.

EDIT: adding sample code:

for (UInt32 i = 0; i < 2; i++)
{
    shared_ptr< derivedRunnable > myRunnable1(new derivedRunnable);
    myExecutor.submit(myRunnable1);
}

Or saving the tasks:

list < shared_ptr < derivedRunnable > > jobs;
for (UInt32 i = 0; i < 2; i++)
{
    shared_ptr< derivedRunnable > myRunnable(new derivedRunnable);
    myExecutor.submit(myRunnable);
    jobs.push_back(myRunnable);
}
// do other stuff
// call a status function that you haven't written yet:
jobs.front()->WaitForCompletion();

By the way, you should also consider switching either to std::thread or boost::thread, depending on the vintage of your compiler.

Answer 2

Your problem is that it is not clear the ownership of the object. From your example it seems clear that the object belongs to the thread, so you should pass ownership, and the thread should destroy it. And for that the IRunnable destructor has to be public. Actually there is no reason for it not to be public.

Ah! And the objects should be created dynamically:

derivedRunnable *myRunnable1 = new derivedRunnable();
myExecutor.submit(myRunnable1);

And the submit function, of course receives a pointer and passes it to the thread. When the thread is done with the runnable, it will destroy it:

void threadfunc(IRunnable *runnable)
{
    //run it
    delete runnable;
}

There are many more sofisticated solutions, but this is the simplest. My favourite, if C++11 is an option, is to use std::unique_ptr<IRunnable>. That way the destruction of the object is automatic. Or if you need to keep the runnable in the main thread, you can use std::shard_ptr<IRunnable>: automatic destruction and shared ownership.

Answer 3

IRunnable needs to have a virtual destructor so that the right destructors are called in the right order.