You cannot read the value of a std::atomic_flag without setting it to true. This is by design. It is not a boolean variable (we have std::atomic<bool> for that), but a minimal flag that is guaranteed lock free on all architectures that support C++11. On some platforms the only atomic instructions are exchange instructions. On such …
Simply use: std::atomic<int> id{}; int create_id() { return id++; } See http://en.cppreference.com/w/cpp/atomic/atomic/operator_arith
Do I have to use atomic for “exit” bool variable? Yes. Either use atomic<bool>, or use manual synchronization through (for instance) an std::mutex. Your program currently contains a data race, with one thread potentially reading a variable while another thread is writing it. This is Undefined Behavior. Per Paragraph 1.10/21 of the C++11 Standard: The …
The C++11 memory ordering parameters for atomic operations specify constraints on the ordering. If you do a store with std::memory_order_release, and a load from another thread reads the value with std::memory_order_acquire then subsequent read operations from the second thread will see any values stored to any memory location by the first thread that were prior …
I have looked for actual data for the past days, and found nothing. However, I did some research, which compares the cost of atomic ops with the costs of cache misses. The cost of the x86 LOCK prefix, (including lock cmpxchg for atomic CAS), before PentiumPro (as described in the doc), is a memory access …
This is absolutely what C++ defines as a Data Race that causes Undefined Behaviour, even if one compiler happened to produce code that did what you hoped on some target machine. You need to use std::atomic for reliable results, but you can use it with memory_order_relaxed if you don’t care about reordering. See below for …
It seems like part what you’re really asking is: Why isn’t the lock prefix implicit for cmpxchg with a memory operand, like it is for xchg (since 386)? The simple answer (that others have given) is simply that Intel designed it this way. But this leads to the question: Why did Intel do that? Is …
For Java 1.7+, use java.nio.file.Files.move(Path source, Path target, CopyOption… options) with CopyOptions “REPLACE_EXISTING” and “ATOMIC_MOVE”. See API documentation for more information. For example: Files.move(src, dst, StandardCopyOption.ATOMIC_MOVE);
I think this a great question and John Calsbeek has the correct answer. However, just to be clear a lazy singleton is best implemented using the classic Meyers singleton. It has garanteed correct semantics in C++11. § 6.7.4 … If control enters the declaration concurrently while the variable is being initialized, the concurrent execution shall …
b = !b is not atomic because in the C++ source you have an atomic pure read of b (equivalent to b.load(), and then a separately-atomic assignment to b (equivalent to b.store()). Nothing makes the entire combination into an atomic RMW operation in the C++ abstract machine, and there’s no syntax for composing arbitrary operations …