Are “data races” and “race condition” actually the same thing in context of concurrent programming

by

No, they are not the same thing. They are not a subset of one another. They are also neither the necessary, nor the sufficient condition for one another.

The definition of a data race is pretty clear, and therefore, its discovery can be automated. A data race occurs when 2 instructions from different threads access the same memory location, at least one of these accesses is a write and there is no synchronization that is mandating any particular order among these accesses.

A race condition is a semantic error. It is a flaw that occurs in the timing or the ordering of events that leads to erroneous program behavior. Many race conditions can be caused by data races, but this is not necessary.

Consider the following simple example where x is a shared variable:

Thread 1    Thread 2

 lock(l)     lock(l)
 x=1         x=2
 unlock(l)   unlock(l)

In this example, the writes to x from thread 1 and 2 are protected by locks, therefore they are always happening in some order enforced by the order with which the locks are acquired at runtime. That is, the writes’ atomicity cannot be broken; there is always a happens before relationship between the two writes in any execution. We just cannot know which write happens before the other a priori.

There is no fixed ordering between the writes, because locks cannot provide this. If the programs’ correctness is compromised, say when the write to x by thread 2 is followed by the write to x in thread 1, we say there is a race condition, although technically there is no data race.

It is far more useful to detect race conditions than data races; however this is also very difficult to achieve.

Constructing the reverse example is also trivial. This blog post also explains the difference very well, with a simple bank transaction example.

More Related Contents:

  1. What is the meaning of the term “thread-safe”?
  2. What is a race condition?
  3. What is the difference between concurrency, parallelism and asynchronous methods?
  4. What is a mutex?
  5. Is this an idiomatic worker thread pool in Go?
  6. JavaFX2: Can I pause a background Task / Service?
  7. What is a semaphore?
  8. What will be used for data exchange between threads are executing on one Core with HT?
  9. Atomic UPDATE .. SELECT in Postgres
  10. How do I share a mutable object between threads using Arc?
  11. Which would be better for concurrent tasks on node.js? Fibers? Web-workers? or Threads?
  12. What is a deadlock?
  13. Asynchronous vs Multithreading – Is there a difference?
  14. What is thread contention?
  15. Number of threads used by Go runtime
  16. How to detect and debug multi-threading problems?
  17. Are incrementers / decrementers (var++, var–) etc thread safe?
  18. Can we have race conditions in a single-thread program?
  19. Simple Deadlock Examples
  20. How to wait for all threads to finish, using ExecutorService?
  21. Is there an advantage to use a Synchronized Method instead of a Synchronized Block?
  22. When and how should I use a ThreadLocal variable?
  23. What is the difference between Thread.start() and Thread.run()?
  24. Why use a ReentrantLock if one can use synchronized(this)?
  25. How to cancel Future in Scala?
  26. How do I implement task prioritization using an ExecutorService in Java 5?
  27. Grasping the Node JS alternative to multithreading
  28. How to handle Task.Run Exception
  29. What happens when different CPU cores write to the same RAM address without synchronization?
  30. Atomically increment two integers with CAS

Leave a Comment