Question

In general, if you have a class that inherits from a Thread class, and you want instances of that class to automatically deallocate after they are finished running, is it okay to delete this?

Specific Example:

In my application I have a Timer class with one static method called schedule. Users call it like so:

Timer::schedule((void*)obj, &callbackFunction, 15); // call callbackFunction(obj) in 15 seconds

The schedule method creates a Task object (which is similar in purpose to a Java TimerTask object). The Task class is private to the Timer class and inherits from the Thread class (which is implemented with pthreads). So the schedule method does this:

Task *task = new Task(obj, callback, seconds);
task->start(); // fork a thread, and call the task's run method

The Task constructor saves the arguments for use in the new thread. In the new thread, the task’s run method is called, which looks like this:

void Timer::Task::run() {
    Thread::sleep(this->seconds);
    this->callback(this->obj);
    delete this;
}

Note that I can’t make the task object a stack allocated object because the new thread needs it. Also, I’ve made the Task class private to the Timer class to prevent others from using it.

I am particularly worried because deleting the Task object means deleting the underlying Thread object. The only state in the Thread object is a pthread_t variable. Is there any way this could come back to bite me? Keep in mind that I do not use the pthread_t variable after the run method finishes.

I could bypass calling delete this by introducing some sort of state (either through an argument to the Thread::start method or something in the Thread constructor) signifying that the method that is forked to should delete the object that it is calling the run method on. However, the code seems to work as is.

Any thoughts?

Answer 1

I think the ‘delete this’ is safe, as long as you don’t do anything else afterwards in the run() method (because all of the Task’s object’s member variables, etc, will be freed memory at that point).

I do wonder about your design though… do you really want to be spawning a new thread every time someone schedules a timer callback? That seems rather inefficient to me. You might look into using a thread pool (or even just a single persistent timer thread, which is really just a thread pool of size one), at least as an optimization for later. (or better yet, implement the timer functionality without spawning extra threads at all… if you’re using an event loop with a timeout feature (like select() or WaitForMultipleObjects()) it is possible to multiplex an arbitrary number of independent timer events inside a single thread’s event loop)