Happens-before relationships with volatile fields and synchronized blocks in Java – and their impact on non-volatile variables?

by

Yes, it is guaranteed that thread 2 will print “done” . Of course, that is if the write to b in Thread 1 actually happens before the read from b in Thread 2, rather than happening at the same time, or earlier!

The heart of the reasoning here is the happens-before relationship. Multithreaded program executions are seen as being made of events. Events can be related by happens-before relationships, which say that one event happens before another. Even if two events are not directly related, if you can trace a chain of happens-before relationships from one event to another, then you can say that one happens before the other.

In your case, you have the following events:

  • Thread 1 writes to s
  • Thread 1 writes to b
  • Thread 2 reads from b
  • Thread 2 reads from s

And the following rules come into play:

  • “If x and y are actions of the same thread and x comes before y in program order, then hb(x, y).” (the program order rule)
  • “A write to a volatile field (ยง8.3.1.4) happens-before every subsequent read of that field.” (the volatile rule)

The following happens-before relationships therefore exist:

  • Thread 1 writes to s happens before Thread 1 writes to b (program order rule)
  • Thread 1 writes to b happens before Thread 2 reads from b (volatile rule)
  • Thread 2 reads from b happens before Thread 2 reads from s (program order rule)

If you follow that chain, you can see that as a result:

  • Thread 1 writes to s happens before Thread 2 reads from s

More Related Contents:

  1. Difference between volatile and synchronized in Java
  2. Java volatile modifier and synchronized blocks
  3. What is the volatile keyword useful for?
  4. What does ‘synchronized’ mean?
  5. Avoid synchronized(this) in Java?
  6. Is there an advantage to use a Synchronized Method instead of a Synchronized Block?
  7. Synchronizing on String objects in Java
  8. Volatile vs Static in Java
  9. What is the difference between atomic / volatile / synchronized?
  10. When exactly do you use the volatile keyword in Java? [duplicate]
  11. Java synchronized method lock on object, or method?
  12. Java Synchronized Block for .class
  13. Synchronization of non-final field
  14. Is a volatile int in Java thread-safe?
  15. If I synchronized two methods on the same class, can they run simultaneously?
  16. Is ConcurrentHashMap totally safe?
  17. Volatile variable in Java
  18. In Java critical sections, what should I synchronize on?
  19. What is the difference between a synchronized method and synchronized block in Java? [duplicate]
  20. do we need volatile when implementing singleton using double-check locking
  21. Simplest and understandable example of volatile keyword in Java
  22. Are volatile variable ‘reads’ as fast as normal reads?
  23. Should you synchronize the run method? Why or why not?
  24. Why doesn’t volatile in java 5+ ensure visibility from another thread?
  25. Java Multithreading concept and join() method
  26. Difference between Synchronized block with wait/notify and without them?
  27. Do two synchronized methods execute simultaneously
  28. If a synchronized method calls another non-synchronized method, is there a lock on the non-synchronized method
  29. When would you call java’s thread.run() instead of thread.start()?
  30. When does the main thread stop in Java?

Leave a Comment