c++ implementing cancel across thread pools

Question

I have several thread pools and I want my application to handle a cancel operation.

To do this I implemented a shared operation controller object which I poll at various spots in each thread pool worker function that is called.

Is this a good model, or is there a better way to do it?

I just worry about having all of these operationController.checkState() littered throughout the code.

Answer 1

Yes it's a good approach. Herb Sutter has a nice article comparing it with the alternatives (which are worse).

Answer 2

With any kind of ansynchronous cancellation you're going to have to periodically poll some sort of flag. There's a fundamental issue of having to keep things in a consitant state. If you just kill a thread in the middle of whatever it's doing, bad things will happen sooner or later.

Depending on what you are actually doing, you may be able to just ignore the result of the operation instead of cancelling it. You let the operation continue on, but just don't wait for it to complete and never check the result.

If you actually need to stop the operation, then you're going to have to poll at appropriate points, and do whatever cleanup is necessary.

Answer 3

It's a good way to do it.

Another possible way to do it is, if there's some other subroutine[s] which the threads call regularly anyway, to check within that subroutine and throw an exception (to be caught at the top of the thread), assuming that "cancel" may be considered exceptional and assuming that the code being executed by the thread is exception-safe.

Answer 4

I wouldn't do it that way, checking a shared object.

I most likely will provide each thread object with a way to cancel the execution inside the own thread, be it an event, a threadsafe state variable or whatever.

The problem with the shared operation controller is that, from my point of view, the logic is reversed, Why are you calling it "controller" when it doesn't control anything?

For me, Operation Controller shall recive a cancelation order and then, in turn select the appropiate threads and signal them to stop. That would be a correct "chain of command" if you know what I mean. The way you do it you introduce an unnatural behaivour on the thread wich doesn't "obey" orders to stop, instead if checks each time if his "superior" has "written the order somewere". Somehow it just doesn't feel right.

In addition, what if you just one "some" of the threads to stop in the future? What if you want to include some advanced logic so that threads will only stop given a condition? Then you'll have to rewrite the code in each and every thread to handle that condition.

So I will provide a way, for each thread to be able to handle signals to them, for example by using a Command Pattern with a FIFO structure.

(By the way, I realize they're thread pool workers, not actual Thread Classes but still, I think each worker must be signaled to stop separately, not the other way around).

Answer 5

In similar situations I have used an event, non-auto-reset, all threads can look at that event. Quite similar to polling except that if your threads block at times, they can sleep for the "stop"-event as well. (Easier on Windows.)

/L