Instruction reordering & happens-before relationship [duplicate]

by

The key point of the program order rule is: in a thread.

Imagine this simple program (all variables initially 0):

T1:

x = 5;
y = 6;

T2:

if (y == 6) System.out.println(x);

From T1’s perspective, an execution must be consistent with y being assigned after x (program order). However from T2’s perspective this does not have to be the case and T2 might print 0.

T1 is actually allowed to assign y first as the 2 assignements are independent and swapping them does not affect T1’s execution.

With proper synchronization, T2 will always print 5 or nothing.

EDIT

You seem to be misinterpreting the meaning of program order. The program order rule boils down to:

If x and y are actions of the same thread and x comes before y in program order, then hb(x, y) (i.e. x happens-before y).

happens-before has a very specific meaning in the JMM. In particular, it does not mean that y=6 must be subsequent to x=5 in T1 from a wall clock perspective. It only means that the sequence of actions executed by T1 must be consistent with that order. You can also refer to JLS 17.4.5:

It should be noted that the presence of a happens-before relationship between two actions does not necessarily imply that they have to take place in that order in an implementation. If the reordering produces results consistent with a legal execution, it is not illegal.

In the example I gave above, you will agree that from T1’s perspective (i.e. in a single threaded program), x=5;y=6; is consistent with y=6;x=5; since you don’t read the values. A statement on the next line is guaranteed, in T1, to see those 2 actions, regardless of the order in which they were performed.

More Related Contents:

  1. How to wait for all threads to finish, using ExecutorService?
  2. Is there an advantage to use a Synchronized Method instead of a Synchronized Block?
  3. Why must wait() always be in synchronized block
  4. When and how should I use a ThreadLocal variable?
  5. What is the difference between Thread.start() and Thread.run()?
  6. Volatile vs Static in Java
  7. When would you call java’s thread.run() instead of thread.start()?
  8. Why use a ReentrantLock if one can use synchronized(this)?
  9. Java Executors: how can I set task priority?
  10. What are the main uses of yield(), and how does it differ from join() and interrupt()?
  11. Volatile variable in Java
  12. What is the JVM thread scheduling algorithm?
  13. How do I implement task prioritization using an ExecutorService in Java 5?
  14. Why does Thread.isInterrupted () always return false?
  15. More efficient way for pausing loop wanted
  16. When should I use a CompletionService over an ExecutorService?
  17. How does `this` reference to an outer class escape through publishing inner class instance?
  18. Are non-synchronised static methods thread safe if they don’t modify static class variables?
  19. Which concurrent Queue implementation should I use in Java?
  20. Why should I use concurrent characteristic in parallel stream with collect?
  21. Java concurrency: is final field (initialized in constructor) thread-safe?
  22. Jboss Java EE container and an ExecutorService
  23. Why doesn’t volatile in java 5+ ensure visibility from another thread?
  24. Concurrent JUnit testing
  25. How to pause/resume all threads in an ExecutorService in Java?
  26. Handling Exceptions for ThreadPoolExecutor
  27. Multithreading Socket communication Client/Server
  28. LinkedBlockingQueue vs ConcurrentLinkedQueue
  29. Setting Ideal size of Thread Pool [duplicate]
  30. Does a breakpoint halt all threads?

Leave a Comment