I claim the minimum value possible is 2. The key to this is the non-atomicity of num++, i.e., it is a read and a write, which may have other operations in between. Call the threads T1..T5: T1 reads 0, T2 reads 0; T1 writes 1, and then reads and writes 3 times. Then T2 writes … Read more
The race condition is, of course, between your program and some other code that operates on file (race condition always requires at least two parallel processes or threads, see this for details). That means using open() instead of exists() may really help only in two situations: You check for existence of a file that is … Read more
Traditionally, forcing race conditions in multithreaded code is done with semaphores, so you can force a thread to wait until another thread has achieved some edge condition before continuing. For example, your object has some code to check that start is not called if the object is already running. You could force this condition to … Read more
Here’s 3 different approaches: Atomic update update table set tries=tries+1 where condition=value; and it will be done atomically. Use row locking If you do need to first select the value and update it in your application, you likely need to use row locking. That means you’ll have to use InnoDB, not MyISAM tables. Your query … Read more
You should have looked to the documentation. That what it says: A Dictionary can support multiple readers concurrently, as long as the collection is not modified. Even so, enumerating through a collection is intrinsically not a thread-safe procedure. In the rare case where an enumeration contends with write accesses, the collection must be locked during … Read more
Yes, race conditions (in the sense of a shared resource having an inconsistent value due to order of events) can still happen anywhere that there’s a point of suspension that could lead to other code being run (with threads its at any line), take for example this piece of async code that is entirely single … Read more
When using serializable transaction SQL Server issues shared locks on read records / tables. Shared locks doesn’t allow other transactions modifying locked data (transactions will block) but it allows other transactions reading data before the transaction which issued locks start modifying data. That is the reason why the example doesn’t work – concurrent reads are … Read more
OP answered his own, but did not directly answer the original question, I am going to post how to correctly use sync.Cond. You do not really need sync.Cond if you have one goroutine for each write and read – a single sync.Mutex would suffice to communicate between them. sync.Cond could useful in situations where multiple … Read more
This is not a definitive answer, but it’s supposed to cover the relevant details I’ve managed to gather about this problem. First, Python’s threading implementation is based on Java’s. Java’s Condition.signal() documentation reads: An implementation may (and typically does) require that the current thread hold the lock associated with this Condition when this method is … Read more
Sorry to put this in as an answer since it’s more of a comment, but it’s too long to fit in as a comment, so here goes: From the site you referenced. Runtime support library for GNU OpenMP (part of GCC), at least for GCC versions 4.2 and 4.3. The GNU OpenMP runtime library (libgomp.so) … Read more