(I’m assuming modern SQL databases in this answer.) tl;dr Transactions are not locks, but hold locks that are acquired automatically during operations. And django does not add any locking by default, so the answer is No, it does not lock the database. E.g. if you were do: @transaction.atomic def update_db(): cursor.execute(‘UPDATE app_model SET model_name TO … Read more
The C standard does not define whether it is atomic or not. In practice, you never write code which fails if a given operation is atomic, but you might well write code which fails if it isn’t. So assume it isn’t.
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 … Read more
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 … Read more
I think that findOneAndUpdate carries out an atomic operation, so I’m assuming that updateOne does not. Why are you assuming that? findOneAndUpdate returns a document whereas updateOne does not (it just returns the _id if it has created a new document). I think that’s the main difference. So the use case of updateOne is when … Read more
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 … Read more
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 … Read more
I believe that Atomic* actually gives both atomicity and volatility. So when you call (say) AtomicInteger.get(), you’re guaranteed to get the latest value. This is documented in the java.util.concurrent.atomic package documentation: The memory effects for accesses and updates of atomics generally follow the rules for volatiles, as stated in section 17.4 of The Java™ Language … Read more
For ObjC Properties — Neither are thread safe. Atomic is more resistant to threading errors. Overall, it is a curious default. The scenarios you would favor atomic for are very few. Atomic can increase the probability of correctness, but it’s at too low a level be considered a substitute for a proper locking mechanism. Therefore, … Read more