inter-process condition variables in Windows

I know that I can use condition variable to synchronize work between the threads, but is there any class like this (condition variable开发者_JAVA技巧) to synchronize work between the processes, thanks in advance

Use a pair of named Semaphore objects, one to signal and one as a lock. Named sync objects on Windows are automatically inter-process, which takes care of that part of the job for you.

A class like this would do the trick.

class InterprocessCondVar {
private: 
    HANDLE  mSem;        // Used to signal waiters
    HANDLE  mLock;       // Semaphore used as inter-process lock 
    int     mWaiters;    // # current waiters 

protected: 

public: 
    InterprocessCondVar(std::string name)
       : mWaiters(0), mLock(NULL), mSem(NULL)
    {
        // NOTE: You'll need a real "security attributes" pointer 
        //   for child processes to see the semaphore! 
        //  "CreateSemaphore" will do nothing but give you the handle if 
        // the semaphore already exists. 
        mSem = CreateSemaphore( NULL, 0, std::numeric_limits<LONG>::max(),  name.c_str()); 

        std::string lockName = name + "_Lock";
        mLock = CreateSemaphore( NULL, 0, 1, lockName.c_str());
        if(!mSem || !mLock) {
            throw std::runtime_exception("Semaphore create failed");
        }
    }
    virtual ~InterprocessCondVar() {
        CloseHandle( mSem);
        CloseHandle( mLock);
    }

    bool Signal();
    bool Broadcast();
    bool Wait(unsigned int waitTimeMs = INFINITE); 
}

A genuine condition variable offers 3 calls:
1) "Signal()": Wake up ONE waiting thread

bool InterprocessCondVar::Signal() {
    WaitForSingleObject( mLock, INFINITE);           // Lock
    mWaiters--;                                      // Lower wait count
    bool result  = ReleaseSemaphore( mSem, 1, NULL); // Signal 1 waiter 
    ReleaseSemaphore( mLock, 1, NULL);               // Unlock 
    return result;
}

2) "Broadcast()": Wake up ALL threads

 bool InterprocessCondVar::Broadcast() {
    WaitForSingleObject( mLock, INFINITE);                 // Lock 
    bool result = ReleaseSemaphore( mSem, nWaiters, NULL); // Signal all
    mWaiters = 0;                                          // All waiters clear;
    ReleaseSemaphore( mLock, 1, NULL);                     // Unlock 
    return result;       
}

3) "Wait()": Wait for the signal

bool InterprocessCondVar::Wait(unsigned int waitTimeMs) {
    WaitForSingleObject( mLock, INFINITE);  // Lock
    mWaiters++;                             // Add to wait count
    ReleaseSemaphore( mLock, 1, NULL);      // Unlock 

    // This must be outside the lock
    return (WaitForSingleObject( mSem, waitTimeMs) == WAIT_OBJECT_0);
}

This should ensure that Broadcast() ONLY wakes up threads & processes that are already waiting, not all future ones too. This is also a VERY heavyweight object. For CondVars that don't need to exist across processes I would create a different class w/ the same API, and use unnamed objects.

You could use named semaphore or named mutex. You could also share memory between processes by shared memory.

For a project I'm working on I needed a condition variable and mutex implementation which can handle dead processes and won't cause other processes to end up in a deadlock in such a case. I implemented the mutex with the native named mutexes provided by the WIN32 api because they can indicate whether a dead process owns the lock by returning WAIT_ABANDONED. The next issue was that I also needed a condition variable I could use across processes together with these mutexes. I started of with the suggestion from user3726672 but soon discovered that there are several issues in which the state of the counter variable and the state of the semaphore ends up being invalid.

After doing some research, I found a paper by Microsoft Research which explains exactly this scenario: Implementing Condition Variables with Semaphores . It uses a separate semaphore for every single thread to solve the mentioned issues.

My final implementation uses a portion of shared memory in which I store a ringbuffer of thread-ids (the id's of the waiting threads). The processes then create their own handle for every named semaphore/thread-id which they have not encountered yet and cache it. The signal/broadcast/wait functions are then quite straight forward and follow the idea of the proposed solution in the paper. Just remember to remove your thread-id from the ringbuffer if your wait operation fails or results in a timeout.

For the Win32 implementation I recommend reading the following documents: Semaphore Objects and Using Mutex Objects as those describe the functions you'll need for the implementation.

Alternatives: boost::interprocess has some robust mutex emulation support but it is based on spin locks and caused a very high cpu load on our embedded system which was the final reason why we were looking into our own implementation.

@user3726672: Could you update your post to point to this post or to the referenced paper?

Best Regards, Michael

Update: I also had a look at an implementation for linux/posix. Turns out pthread already provides everything you'll need. Just put pthread_cond_t and pthread_mutex_t in some shared memory to share it with the other process and initialize both with PTHREAD_PROCESS_SHARED. Also set PTHREAD_MUTEX_ROBUST on the mutex.

Yes. You can use a (named) Mutex for that. Use CreateMutex to create one. You then wait for it (with functions like WaitForSingleObject), and release it when you're done with ReleaseMutex.

For reference, Boost.Interprocess (documentation for version 1.59) has condition variables and much more. Please note, however, that as of this writing, that "Win32 synchronization is too basic".