如何保护两个进程之间共享 memory 中的字符串？

Question

I have a piece of shared memory that contains a char string and an integer between two processes.

Process A writes to it and Process B reads it (and not vice versa)

What is the most efficient and effective way to make sure that Process A doesn't happen to update (write to it) that same time Process B is reading it? (Should I just use flags in the shared memory, use semaphores, critical section....)

If you could point me in the right direction, I would appreciate it.

Thanks.

Windows, C++

Answer 1

You cannot use a Critical Section because these can only be used for synchronization between threads within the same process. For inter process synchronization you need to use a Mutex or a Semaphore . The difference between these two is that the former allows only a single thread to own a resource, while the latter can allow up to a maximum number (specified during creation) to own the resource simultaneously.

In your case a Mutex seems appropriate.

Answer 2

Since you have two processes you need a cross-process synchronisation object. I think this means that you need to use a mutex .

Answer 3

A mutex object facilitates protection against data races and allows thread-safe synchronization of data between threads. A thread obtains ownership of a mutex object by calling one of the lock functions and relinquishes ownership by calling the corresponding unlock function.

If you are using boost thread, you can use it's mutex and locking, more to read see the link below:

http://www.boost.org/doc/libs/1_47_0/doc/html/thread/synchronization.html#thread.synchronization.mutex_types

Answer 4

Since you're talking about two processes, system-wide mutexes will work, and Windows has those. However, they aren't necessarily the most efficient way.

If you can put more things in shared memory, then passing data via atomic operations on flags in that memory should be the most efficient thing to do. For instance, you might use the Interlocked functions to implement Dekker's Algorithm (you'll probably want to use something like YieldProcessor() to avoid busy waiting).