UPDATE query places an update lock on the pages or records it reads. When a decision is made whether to update the record, the lock is either lifted or promoted to the exclusive lock. This means that in this scenario: s1: read counter for image_id=15, get 0, store in temp1 s2: read counter for image_id=15, … Read more
INSERT INTO <table> SELECT <natural keys>, <other stuff…> FROM <table> WHERE NOT EXISTS — race condition risk here? ( SELECT 1 FROM <table> WHERE <natural keys> ) UPDATE … WHERE <natural keys> there is a race condition in the first INSERT. The key may not exists during the inner query SELECT, but does exist at … Read more
The standard does not specify if atomic objects are lock-free. On a platform that doesn’t provide lock-free atomic operations for a type T, atomic<T> objects may be implemented using a mutex, which wouldn’t be lock-free. In that case, any containers using these objects in their implementation would not be lock-free either. The standard does provide … Read more
As described in this closely related question that was mentioned in the comments, std::atomic<T> isn’t copy-constructible, nor copy-assignable. Object types that don’t have these properties cannot be used as elements of std::vector. However, it should be possible to create a wrapper around the std::atomic<T> element that is copy-constructible and copy-assignable. It will have to use … Read more
This is a known issue in Visual Studio 2012 (known as VC11), you should vote on the existing Connect item so that Microsoft knows it affects more folks as they’ve deferred the fix. Hi, Thanks for reporting this bug. I’m Microsoft’s maintainer of the STL, and I wanted to let you know that while this … Read more
Reading/writing references always atomic See JLS section 17.7: Non-atomic Treatment of double and long For the purposes of the Java programming language memory model, a single write to a non-volatile long or double value is treated as two separate writes: one to each 32-bit half. This can result in a situation where a thread sees … Read more
Yes and no. rename() is atomic assuming the OS does not crash. It cannot be split by any other filesystem op. If the system crashes you might see a ln() operation instead. Also note, when operating on a network filesystem, you might get ENOENT when the operation succeeded successfully. Local filesystem can’t do that to … Read more
Another solution that’s been proposed for this is POST Once Exactly (POE), in which the server generates single-use POST URIs that, when used more than once, will cause the server to return a 405 response. The downsides are that 1) the POE draft was allowed to expire without any further progress on standardization, and thus … Read more
I’m not an expert on this, and it’s really complicated, so please feel free to critique my post. As pointed out by mdh.heydari, cppreference.com has much better documentation of orderings than Rust (C++ has an almost identical API). For your question You’d need to use “release” ordering in your producer and “acquire” ordering in your … 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