The spinlock mutex implementation looks okay to me. I think they got the definitions of acquire and release completely wrong. Here is the clearest explanation of acquire/release consistency models that I am aware of: Gharachorloo; Lenoski; Laudon; Gibbons; Gupta; Hennessy: Memory consistency and event ordering in scalable shared-memory multiprocessors, Int’l Symp Comp Arch, ISCA(17):15-26, 1990, … Read more
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 … Read more
Projects are using this: http://packages.debian.org/source/sid/libatomic-ops If you want simple operations such as CAS, can’t you just just use the arch-specific implementations out of the kernel, and do arch checks in user-space with autotools/cmake? As far as licensing goes, although the kernel is GPL, I think it’s arguable that the inline assembly for these operations is … Read more
No, fundamental data types (e.g., int, double) are not atomic, see std::atomic. Instead you can use std::atomic<int> or std::atomic<double>. Note: std::atomic was introduced with C++11 and my understanding is that prior to C++11, the C++ standard didn’t recognize the existence of multithreading at all. As pointed out by @Josh, std::atomic_flag is an atomic boolean type. … Read more
Why doing exchange in a loop? Usually, you want your work to be done before you move on, thus, you put compare_exchange_weak into a loop so that it tries to exchange until it succeeds (i.e., returns true). Note that also compare_exchange_strong is often used in a loop. It does not fail due to spurious failure, … Read more
Atomic operations leverage processor support (compare and swap instructions) and don’t use locks at all, whereas locks are more OS-dependent and perform differently on, for example, Win and Linux. Locks actually suspend thread execution, freeing up cpu resources for other tasks, but incurring in obvious context-switching overhead when stopping/restarting the thread. On the contrary, threads … Read more
For the final, definitive answer to this question, jump straight down to the section below titled “Final answer to my question“. UPDATE 30 Oct. 2018: I was accidentally referencing the (slightly) wrong documents (but which said the exact same thing), so I’ve fixed them in my answer here. See “Notes about the 30 Oct. 2018 … Read more
Since this answer is long, here’s the summary: No, file_get_contents() is not atomic as it does not respect advisory locks. About file locks in PHP: In PHP, while on a *nix platform, filesystem locking is advisory only. Per the docs (Emphasis mine): PHP supports a portable way of locking complete files in an advisory way … Read more
Let’s see: >>> x = 1 >>> y = 2 >>> def swap_xy(): … global x, y … (x, y) = (y, x) … >>> dis.dis(swap_xy) 3 0 LOAD_GLOBAL 0 (y) 3 LOAD_GLOBAL 1 (x) 6 ROT_TWO 7 STORE_GLOBAL 1 (x) 10 STORE_GLOBAL 0 (y) 13 LOAD_CONST 0 (None) 16 RETURN_VALUE It doesn’t appear that … Read more