enum wait_result { wait_ok, wait_timeout, wait_stop, wait_error };

wait_result waitForSingleObject(HANDLE obj, unsigned timeout)
{
  HANDLE objs[2] =
  {
    getThreadStopper(), // имеет более высокий приоритет: если оба объекта в сигнальном состоянии, то получим именно stop
    obj
  };
  unsigned result = WaitForSingleObject(objs,2,timeout);
  switch(result)
  {
  case WAIT_OBJECT_0:   return wait_stop;
  case WAIT_OBJECT_0+1: return wait_ok;
  case WAIT_TIMEOUT:    return wait_timeout;
  default:              return wait_error;
  };
}

wait_result stopThread(HANDLE thread, unsigned timeout)
{
  HANDLE stopper = getThreadStopper(thread);
  if(!stopper) return wait_error;
  SetEvent(stopper);
  return waitForSingleObject(thread,timeout); // ждём, когда поток перейдёт в сигнальное состояние (т.е. завершится)
}

// реализации функций getThreadStopper(), getThreadStopper(HANDLE thread) - на ваше усмотрение. Можно использовать TLS.

class stop_thread {};

bool waitOne(HANDLE obj, unsigned timeout)
{
  wait_result wr = waitForSingleObject(obj,timeout); // см. выше
  switch(wr)
  {
  case wait_ok: return true;
  case wait_timeout: return false;
  case wait_error: throw logic_error("wait failed"); // или какой-нибудь ещё класс
  case wait_stop: throw stop_thread(); // а вот это - обязательно отдельный класс, не надо его мешать с другими исключениями
  }
}

bool testStop()
{
  waitOne(0,0);
  return true;
}


class LockMutex : boost::noncopyable
{
  HANDLE mutex;
public:
  explicit LockMutex(HANDLE m) : mutex(m) { waitOne(m,INFINITE); }
  ~LockMutex() { ReleaseMutex(mutex); }
};

void foo()
{
  try
  {
    .......
    LockMutex(resource_sentry);
    .......
    for(i=0;testStop() && i<10000000;++i) { ...... }
    .......
  }
  catch(const stop_thread& )
  {
    cout << "The thread is being stopped!";
    throw;
  }
}

DWORD   status;
do {

status = WaitForSingleObjectEx( hEventIO, INFINITE, TRUE );

//выполнили АРС
if ( status == WAIT_IO_COMPLETION )
    continue; //продолжаем ожидать сигнализации hEventIO - окончания ВВ

break;

}  while ( 1 );

QueueUserAPC( StopThreadAPC, TargetThread, 0 );

VOID CALLBACK APCProc(ULONG_PTR dwParam)
{
  CancelIo( hDev ); //отменяем операцию - в результате будет сигнализировано событие hEventIO
}

К>class stop_thread {};

К>bool waitOne(HANDLE obj, unsigned timeout)
К>{
К>  wait_result wr = waitForSingleObject(obj,timeout); // см. выше
К>  switch(wr)
К>  {
К>  case wait_ok: return true;
К>  case wait_timeout: return false;
К>  case wait_error: throw logic_error("wait failed"); // или какой-нибудь ещё класс
К>  case wait_stop: throw stop_thread(); // а вот это - обязательно отдельный класс, не надо его мешать с другими исключениями
К>  }
К>}

К>bool testStop()
К>{
К>  waitOne(0,0);
К>  return true;
К>}


К>class LockMutex : boost::noncopyable
К>{
К>  HANDLE mutex;
К>public:
К>  explicit LockMutex(HANDLE m) : mutex(m) { waitOne(m,INFINITE); }
К>  ~LockMutex() { ReleaseMutex(mutex); }
К>};
К>

К>void foo()
К>{
К>  try
К>  {
К>    .......
К>    LockMutex(resource_sentry);
К>    .......
К>    for(i=0;testStop() && i<10000000;++i) { ...... }
К>    .......
К>  }
К>  catch(const stop_thread& )
К>  {
К>    cout << "The thread is being stopped!";
К>    throw;
К>  }
К>}
К>

TC>Вы УВЕРЕНЫ, что это облегчит жизнь?

some foo()
{
  do_something();
  if(!ThisThreadIsOver()) do_something_more();
  if(!ThisThreadIsOver()) and_more();
  if(!ThisThreadIsOver()) return all_right;

  do_stop();
  return please_stop_me;
}

// versus

some foo()
{
  try
  {
    do_something();
    testStop();
    do_something_more();
    testStop();
    and_more();
    testStop();
    return all_right;
  }
  catch(stop_thread const&) // если do_stop() - нетривиально
  {
    do_stop();
    throw;
  }
}

some foo()
{
  try
  {
    ........
    return all_right;
  }
  catch(stop_thread const&) {}

  do_stop();
  throw stop_thread();
}