CODEWITHSUNDEEP
c++windowsmultithreadingsocketsc++11
PowerGamer
PowerGamer

Reputation: 2136

Portable C++11 way to wait on a socket and bool var at the same time

I have a thread with endless loop that receieves and processes data from a socket. I want that thread to block (sleep) until the data becomes available on the socket for reading or the "exit" boolean variable becomes true (set by a different thread). Is it possible to do that in a portable way without polling and using any third-party libraries (except sockets library naturally)? If it is not possible to do in a portable way what would be the best way to do it under Windows (still NO polling and third-party libraries)?

Example code:

bool exit = false; // or "std::atomic<bool> exit" or anything else
void fn()
{
    SOCKET s;
    // init socket, establish connection, etc
    for(;;)
    {
        // This thread goes to wait (blocks) until data becomes available on socket
        // OR exit var is set to true (by a different thread) - how?
        if(exit) break;
        // receive and process data from socket
    }
}

Upvotes: 4

Views: 1026

Answers (1)

Yakk - Adam Nevraumont
Yakk - Adam Nevraumont

Reputation: 275405

Set up a queue of messages.

These messages are of the form "PleaseExit" or "DataOnSocket".

Your thread, or task, is activated when anything shows up in the queue, processes the queue, then waits on the queue again. If it gets "PleaseExit" it instead starts cleaning up.

Possibly you will have to have a different thread/task waiting on the condition variable and on the socket to ferry the information over to your unified queue.

I say "thread or task", because having an entire thread dedicated to waiting is overkill. Sadly, C++11 threading doesn't support light weight tasks out of the box perfectly.

Basically, this solution allows a thread to wait on multiple events by delegating the waiting on each event to other threads, which send notifications "up the pipe". You could imagine creating a common infrastructure, where your thread that wants to wait on multiple objects tells the dispatch center what it is waiting for, then waits on its own condition condition variable.

The dispatch center waits on each of the things your thread wanted to wait for, and when they occur proceeds to figure out which threads should be notified, then notifies them.

Far, far from ideal, but it does let you do it in fully standards compliant C++11 land. And can give you an interface much like "wait for multiple objects" from windows. (In fact, on windows, you could do away with much of the machinery if the native_handle of your C++11 synchronization primitives are amenable).

Upvotes: 1

Related Questions