Does std::mutex create a fence?

by

As I understand this is covered in:

1.10 Multi-threaded executions and data races

Para 5:

The library defines a number of atomic operations (Clause 29) and operations on mutexes (Clause 30)
that are specially identified as synchronization operations. These operations play a special role in making assignments in one thread visible to another. A synchronization operation on one or more memory locations is either a consume operation, an acquire operation, a release operation, or both an acquire and release operation. A synchronization operation without an associated memory location is a fence and can be either an acquire fence, a release fence, or both an acquire and release fence. In addition, there are relaxed atomic operations, which are not synchronization operations, and atomic read-modify-write operations, which have special characteristics. [Note: For example, a call that acquires a mutex will perform an acquire operation on the locations comprising the mutex. Correspondingly, a call that releases the same mutex will perform a release operation on those same locations. Informally, performing a release operation on A forces prior side effects on other memory locations to become visible to other threads that later perform a consume or an acquire operation on A. “Relaxed” atomic operations are not synchronization operations even though, like synchronization operations, they cannot contribute to data races. —end note]

More Related Contents:

  1. Acquire/release semantics with 4 threads
  2. C++11 introduced a standardized memory model. What does it mean? And how is it going to affect C++ programming?
  3. Example for boost shared_mutex (multiple reads/one write)?
  4. Mutex example / tutorial? [closed]
  5. understanding of pthread_cond_wait() and pthread_cond_signal()
  6. When should I use _mm_sfence _mm_lfence and _mm_mfence
  7. Atomicity on x86
  8. How to give priority to privileged thread in mutex locking?
  9. How can I use something like std::vector?
  10. C++ How is release-and-acquire achieved on x86 only using MOV?
  11. Is it smart to replace boost::thread and boost::mutex with c++11 equivalents?
  12. c++, std::atomic, what is std::memory_order and how to use them?
  13. When to use recursive mutex?
  14. C++11 memory_order_acquire and memory_order_release semantics?
  15. How to implement a unmanaged thread-safe collection when I get this error: is not supported when compiling with /clr
  16. Thread pooling in C++11
  17. How to check if a std::thread is still running?
  18. What exactly is std::atomic?
  19. Why do I need a memory barrier?
  20. std::unique_lock or std::lock_guard?
  21. What are the differences between various threading synchronization options in C#?
  22. STL vector and thread-safety
  23. Thread safety of std::map for read-only operations
  24. Passing arguments to std::async by reference fails
  25. C++ mutex in namespace std does not name a type
  26. boost thread throwing exception “thread_resource_error: resource temporarily unavailable”
  27. In Visual Studio, `thread_local` variables’ destructor not called when used with std::async, is this a bug?
  28. Making a C++ class a Monitor (in the concurrent sense)
  29. C++11 std::mutex in Visual Studio 2012 deadlock when locked from DllMain()
  30. is winsock2 thread safe?

Leave a Comment