Pitfalls: Injecting an exception to another thread in the same pro

Hi,

Basically I2"m tired of always polling the 2?should_I_abort2" variable in
worker threads. I was thinking, what if I made my worker thread exception
safe, and forcibly injected an exception from my other thread?

I2"m sure it2"s possible but before I look further into it, i thought I'd ask
around here for potential pitfalls or limitations of injecting an exception
into another thread.

A few things i'm specifically interested in:
What sort of problems (if any) could i run into if i inject an exception
into a system function?
I'm pretty sure that i could run into problems if the exception is injected
before the worker thread enters MyProc - or after - looks like it would
require some extra protection (read: race condition).

Example code is contained bellow:

UINT __cdecl MyProc(PVOID /*unused*/);

class CMyClass
{
    CWinThread * mythread;
public:
    CMyClass() : mythread(NULL)
    {

    }
    ~CMyClass()
    {
        if(mythread)
            EndThread();
    }
    void CMyClass::StartThread()
    {
        //create the thread in the suspended state
        //(we will call ResumeThread() bellow once
        //we have set m_bAutoDelete to FALSE)
        mythread = AfxBeginThread(&MyProc,NULL,0,0,CREATE_SUSPENDED);

        //check to make sure thread was created successfuly
        if(!mythread)
            throw std::runtime_error("Error! thread creation failed");

        //don't auto delete or we can run into problems while
        //waiting on the thread handle
        mythread->m_bAutoDelete = FALSE;

        //resume the thread
        mythread->ResumeThread();
    }
    void CMyClass::EndThread()
    {
        //check that the thread was created
        if(!mythread)
            throw std::runtime_error(
                "Error!, can't EndThread() "
                "without first calling StartThread()");

        //***************************************//
        //todo: Need to inject an exception into mythread here
        //I'm not sure how to do it yet, but i'm sure i'll need the
        //thread handle
        //***************************************//
        InjectException(mythread->m_hThread); // ???

        //wait for it to complete
        WaitForSingleObject(mythread->m_hThread,INFINITE);

        //delete it
        delete mythread;
    }
};
//example use
void TestInjectionException()
{
    //put up a wait cursor
    CWaitCursor cur;

    //create CMyClass
    CMyClass myclass;

    //start the thread
    myclass.StartThread();

    //just wait a while
    Sleep(2000);

    //kill the thread
    myclass.EndThread();
}

UINT __cdecl MyProc(PVOID /*unused*/)
{
    try
    {
        while(1)
        {

            //this would really be some lengthy calculation

            //Realize that injecting an exception into a
            //system function could cause problems. The
            //intention is for tasks that don't use system
            //calls. Some sort of protection could also be
            //used to delay (read: Block) the thread that is
            //trying to inject an exception into this thread
            //using a CRITICAL_SECTION. Performance
            //issues??
            ::Sleep(1000);
        }
    }
    catch (...)
    {
        //compiler will warn about unreachable code
        //may need to make sure that it does not
        //optimize out the try-catch block
        return 0;
    }
    return 1;
}