c++ winapi threads

Question

These days I'm trying to learn more things about threads in windows. I thought about making this practical application:

Let's say there are several threads started when a button "Start" is pressed. Assume these threads are intensive (they keep running / have always something to work on).

This app would also have a "Stop" button. When this button is pressed all the threads should close in a nice way: free resources and abandon work and return the state they were before the "Start" button was pressed.

Another request of the app is that the functions runned by the threads shouldn't contain any instruction checking if the "Stop" button was pressed. The function running in the thread shouldn't care about the stop button.

Language: C++

OS: Windows

Problems:

WrapperFunc(function, param)    
{
     // what to write here ?
     // if i write this:
     function(param);
     // i cannot stop the function from executing
}

• How should I construct the wrapper function so that I can stop the thread properly? ( without using TerminateThread or some other functions )

• What if the programmer allocates some memory dynamically? How can I free it before closing the thread?( note that when I press "Stop button" the thread is still processing data) I though about overloading the new operator or just imposing the usage of a predefined function to be used when allocating memory dynamically. This, however, means that the programmer who uses this api is constrained and it's not what I want.

Thank you

Edit: Skeleton to describe the functionality I'd like to achieve.

struct wrapper_data
{
      void* (*function)(LPVOID);
      LPVOID *params;
};

/* 
this function should make sure that the threads stop properly
( free memory allocated dynamically etc )
*/
void* WrapperFunc(LPVOID *arg)    
{
     wrapper_data *data = (wrapper_data*) arg;
     // what to write here ?
     // if i write this:
     data->function(data->params);
     // i cannot stop the function from executing
     delete data;
}

// will have exactly the same arguments as CreateThread
MyCreateThread(..., function, params, ...)
{
    // this should create a thread that runs the wrapper function
    wrapper_data *data = new wrapper_data;
    data->function = function;
    data->params = params;

    CreateThread(..., WrapperFunc, (LPVOID) wrapper_data, ...);
}

thread_function(LPVOID *data)
{
   while(1)
   {
        //do stuff
   }
}

// as you can see I want it to be completely invisible 
// to the programmer who uses this
MyCreateThread(..., thread_function, (LPVOID) params,...);

Answer 1

One solution is to have some kind of signal that tells the threads to stop working. Often this can be a global boolean variable that is normally false but when set to true it tells the threads to stop. As for the cleaning up, do it when the threads main loop is done before returning from the thread.

I.e. something like this:

volatile bool gStopThreads = false;  // Defaults to false, threads should not stop

void thread_function()
{
    while (!gStopThreads)
    {
        // Do some stuff
    }

    // All processing done, clean up after my self here
}

---

As for the cleaning up bit, if you keep the data inside a struct or a class, you can forcibly kill them from outside the threads and just either delete the instances if you allocated them dynamically or let the system handle it if created e.g. on the stack or as global objects. Of course, all data your thread allocates (including files, sockets etc.) must be placed in this structure or class.

---

A way of keeping the stopping functionality in the wrapper, is to have the actual main loop in the wrapper, together with the check for the stop-signal. Then in the main loop just call a doStuff-like function that does the actual processing. However, if it contains operations that might take time, you end up with the first problem again.

Answer 2

See my answer to this similar question:

How do I guarantee fast shutdown of my win32 app?

Basically, you can use QueueUserAPC to queue a proc which throws an exception. The exception should bubble all the way up to a 'catch' in your thread proc.

As long as any libraries you're using are reasonably exception-aware and use RAII, this works remarkably well. I haven't successfully got this working with boost::threads however, as it's doesn't put suspended threads into an alertable wait state, so QueueUserAPC can't wake them.

Answer 3

If you don't want the "programmer" of the function that the thread will execute deal with the "stop" event, make the thread execute a function of "you" that deals with the "stop" event and when that event isn't signaled executes the "programmer" function...

In other words the "while(!event)" will be in a function that calls the "job" function.

Code Sample.

typedef void (*JobFunction)(LPVOID params); // The prototype of the function to execute inside the thread

struct structFunctionParams
{
    int iCounter;
    structFunctionParams()
    {
        iCounter = 0;
    }
};

struct structJobParams
{
    bool bStop;
    JobFunction pFunction;
    LPVOID pFunctionParams;
    structJobParams()
    {
        bStop = false;
        pFunction = NULL;
        pFunctionParams = NULL;
    }
};

DWORD WINAPI ThreadProcessJob(IN LPVOID pParams)
{
    structJobParams* pJobParams = (structJobParams*)pParams;
    while(!pJobParams->bStop)   
    {
        // Execute the "programmer" function
        pJobParams->pFunction(pJobParams->pFunctionParams);
    }   

    return 0;
}


void ThreadFunction(LPVOID pParams)
{
    // Do Something....
    ((structFunctionParams*)pParams)->iCounter ++;
}


int _tmain(int argc, _TCHAR* argv[])
{   
    structFunctionParams stFunctionParams;

    structJobParams stJobParams;
    stJobParams.pFunction = &ThreadFunction;
    stJobParams.pFunctionParams = &stFunctionParams;




    DWORD dwIdThread = 0;
    HANDLE hThread = CreateThread( 
        NULL,
        0, 
        ThreadProcessJob,
        (LPVOID) &stJobParams, 0, &dwIdThread);
    if(hThread) 
    {   
            // Give it 5 seconds to work
        Sleep(5000);
        stJobParams.bStop = true; // Signal to Stop
        WaitForSingleObject(hThread, INFINITE); // Wait to finish
        CloseHandle(hThread);
    }
}