Re: how to kill a worker thread that doesn't do any work in a loop

On Sep 15, 7:07 pm, Seetharam <smi...@gmail.com> wrote:


First of all, there is no, and I repeat, NO, good way to forcibly
terminate an MFC (or CRT) thread from the outside. There is only one
possible way, and that is to ask it to stop (e.g. with a shared flag)
and then wait that it realizes that it should stop and do it by
itself.

This is hard, cold truth, and the sooner everybody gets that into
their own thick skulls, the better. :-)

Why is that? Because MFC and CRT threads contain internal state that
is cleaned up when thread terminates. This can only be done, and is,
upon normal termination, or upon appropriate termination function call
from within the thread (e.g. AfxEndThread()). If this is not done,
which it can't be upon any forcible termination, said cleanup does not
occur. At best, in practice, it results in a memory and handle leaks,
but in fact falls under undefined behavior. It is really good that you
didn't find any code that seems to offer a solution, because it could
only have been wrong.

(There is TerminateThread API call, but that is usable only for
threads that are not using CRT, MFC and that do not own any resources
of their own at any time where TerminateThread might get called. And
that, that is such a tall order, that it's virtually impossible to
code anything meaningful with it.)

To reiterate what Doug said, thread termination function is not great
either: prior to calling it, thread must release any resources it
currently holds, and, in the case of C++ code, call destructors of all
it's live stack objects. That's a tall order, too. (E.g. already one
call deep inside thread func, AfxEndThread is likely useless).

That said...

What you can do in your particular situation is to derive from CFile
and put some sort of "cancel" flag in. Only method you will have to
override is Read. Inside, check for "cancelled" flag and throw an
exception, e.g.

UINT CMyFile::Read(params)
{
  if (IsCancelled())
    throw new CMyFileCancelledException;
  UINT n = __super::Read(params).
  if (IsCancelled())
    throw new CMyFileCancelledException;
  return n;
}

You need exception type and IsCancelled method. For your controlling
(UI?) thread, you need to be able to call CMyFile::CancelPrettyPlease
(), that you need to write, too. In general, that's easy, it's just a
flag to write/read, and it only may go from false to true.

All that does not give you the opportunity to terminate the thread
__immediately__. You will still need to wait for the thread to pick
the flag up. But it's only, and I repeat, ONLY proper solution for
thread termination.

Goran.