Java语句的执行顺序

Question

Since order of execution is not guaranteed. In below program order of execution for main method can be like below ?

 t2.start();
 t2.join(); 
 t1.start();
 t1.join(); 

Program is:

public class Puzzle {
  static boolean answerReady = false;
  static int answer = 0;
  static Thread t1 =
      new Thread() {
        public void run() {
          answer = 42;
          answerReady = true;
        }
      };
  static Thread t2 =
      new Thread() {
        public void run() {
          while (!answerReady) Thread.sleep(100);
          System.out.println("The meaning of life is: " + answer);
        }
      };

  public static void main(String[] args) throws InterruptedException {
    t1.start();
    t2.start();
    t1.join();
    t2.join();
  }
}

Edit: want to add few things after seeing comments

1. answerReady may never become true. Agree.
2. what are special conditions when order of execution can be changed ?
3. why main method is correctly synchronized here ?

Answer 1

The Java Language Specification dictates what conforming JVMs may do or not. See

§17.4.5. Happens-before Order

Two actions can be ordered by a happens-before relationship. If one action happens-before another, then the first is visible to and ordered before the second.

If we have two actions x and y , we write hb(x, y) to indicate that x happens-before y .

• If x and y are actions of the same thread and x comes before y in program order, then hb(x, y) .
• …

Since your invocations of start() and join() are actions of the same thread, they are ordered in respect to the program order.

I think, it should be obvious that if that simple guaranty didn't exist, even single threaded programming was impossible.

This does not imply the absence of reordering in the code. It only implies that such optimizations must happen in a way that retains the observable behavior of these actions when executing this code.

The point here is, that while the main thread will consistently do what you told it to do, other threads not having a happens-before relationship to either of these actions, might not see the actions in the same way. In your case, with the three threads shown, there are several relationships:

_{continuation of §17.4.5}

• …
• If hb(x, y) and hb(y, z) , then hb(x, z) .

…

• A call to start() on a thread happens-before any actions in the started thread.
• All actions in a thread happen-before any other thread successfully returns from a join() on that thread.

From this you can derive that all three threads of your code agree on what the main thread is doing in most parts.

Of course, this doesn't change the fact that the two spawned threads are improperly (not at all) synchronized and t2 may print the value 0 instead of 42 or never terminate at all.

Answer 2

No. the order of execution on the main thread is as you've declared it in main :

t1.start();
t2.start();
t1.join();
t2.join();

The only thing that's not guaraneed is the content of the threads t1 and t2 .