8

Today I read java interview questions and I read this question: Question : Consider the following Java code snippet, which is initializing two variables and both are not volatile, and two threads T1 and T2 are modifying these values as following, both are not synchronized

int x = 0;
boolean bExit = false;

Thread 1 (not synchronized)
x = 1; 
bExit = true;

Thread 2 (not synchronized)
if (bExit == true) 
System.out.println("x=" + x);

Now tell us, is it possible for Thread 2 to print “x=0”?

So, the answer is "yes". In the explanation there is "because without any instruction to compiler e.g. synchronized or volatile, bExit=true might come before x=1 in compiler reordering." Before that I don't know that the compiler can execute one line before another line after it.

Why is this reordering ? And what if I print something to the console from different thread - the line that is supposed to be print first will be print after the line that is supposed to be print second (if they are printed from the same thread) ? It's weird to me (maybe, because I saw this thing for reordering for the first time). Can someone give some explanation ?

Improve this question
7
  • 1
    Remember, both threads are running at the same time. Without synchronization, the first thread could execute int x = 0; and then the second thread could execute bExit == true; There is no reordering, there is only two threads executing. Reordering would occur if, and when, synchronization is implemented. Don't make assumptions about what two threads will do independently of each other. For example, one invalid assumption is that the same code will always take the same amount of time to execute in two different threads. Commented Jun 23, 2015 at 23:32
  • I must be misunderstanding the question. From my perspective, there's no way that x=0 will ever be printed. Commented Jun 23, 2015 at 23:41
  • 1
    @RobertHarvey Only if the statements can be executed out of order in an individual thread. Because for "x=0" to print, the second line of thread 1 needs to execute before the first line of thread 1. Other commenters are saying that is indeed possible; I would have thought not but am open to it. Commented Jun 24, 2015 at 12:59
  • 1
    @DavidP.Caldwell: Thread 1 executes x=1; the main thread executes both statements, thread 1 executes bExit = true; thread 2 executes both statements. Commented Jun 24, 2015 at 14:32
  • 1
    @RobertHarvey ah, you are assuming the main thread is running concurrently with the other two. I am assuming those statements executed before either "Thread 1" or "Thread 2" was started, given the way the question was worded and the reason given by the "answer" on the study guide questioner was using ("compiler reordering," not "you don't understand multithreading"). Makes sense why we see it differently. Commented Jun 24, 2015 at 17:26

3 Answers 3

Reset to default
8

The JIT compiler* can change the order of execution if it won't change the result according to the Java standard. Switching

x = 1;
bExit = true;

to

bExit = true;
x = 1;

does not change the result because there is no synchronization, ie. according to the standard, these variables should not be read by another thread while doing this, and neither of these statements need the other variable. (On modern CPUs, both commands will in fact be executed at the same time which of course means it is unspecified which will be changed first.)

Not only reordering can cause that behavior. It may happen that bExit can be in one memory page and x in another and if the application is running on a multi-processor (or multi-core) system, then without synchronization, it can happen that memory page with bExit will be committed (and changes to it will be visible in all other cores) before memory page with x.

*Edit: Java compiler (compiling .java into .class) cannot change in-thread execution order but JIT compiler (compiling .class into binary code) can. However Java compiler can omit some statements if it thinks they are redundant, eg.

x = 1;
bExit = true;
x = 2;

can optimize away x = 1;

Improve this answer
Sign up to request clarification or add additional context in comments.

18 Comments

But it does change the result. If the compiler did not make those reorderings, you're guaranteed to never see x=0. But if it does make those changes, then the behavior is undefined. (You might see it, you might not.) In my opinion this is not just a race condition, but fundamentally altering the behavior of the program.
You're basically correct, @CraigOtis, the compiler never makes those reorderings. Execution is guaranteed in-order within a thread. However, hardware can reorder memory writes, and will do so unpredictably. So the second thread might see bExit == true before x is written, although the first thread will never see them in reverse order.
@CraigOtis It does not change the result as per Java specification because reading unsynchronized variable while changing it in another thread should never happen in well-formed program.
@CraigOtis "If the compiler did not make those reorderings, you're guaranteed to never see x=0." Not so. Any number of other things can cause writes to be reordered such as posted write buffers in the CPU. It doesn't make sense to force every single memory operation that ever happens to occur in strict order just because ordering between such operations is occasionally needed. It makes more sense to ask for it when you need it. How about x = 1; bExit = true; x = 2; (which can occur as a result of dead code elimination), you want to argue the first x=1; can't be optimized out? Really?
@DavidSchwartz I did a quick read of that paper. It says "This paper refutes this conventional wisdom by showing one way to scale on-chip cache coherence". On-Chip is important there. I'm talking about cores on different sockets; more than one physical CPU in a single system. Those caches on separate sockets are definitely not maintained coherent. Sorry if my terminology was imprecise, but on a typical 8 or 16 core system some of those caches won't be coherent.
|
2

So, to sum up - "x=0" can be print because of: - compiler reordering - if x is 1 and bExit is true, but the second thread see only changes in bExit. So bExit will be true and it will print the value of x, but it won't see the changes in x and it will print 0. Fixed me if there is mistakes in this summing up. Thanks of all of you for your time and answers.

Improve this answer

1 Comment

Yes good summary. The comments David and Robert made on your initial question are worth looking at. The big question was whether these are three threads already running, or if it's a piece of code where the two variables are assigned their initial values by the main system thread, and after that Thread 1 & 2 are launched. David assumed this latter setup, and so do I. And with that assumption, yes, it looks like bytecode instruction reordering at runtime will allow for x=0 to be printed. David put it well "Only if the statements can be executed out of order in an individual thread".
0

Threads are given runtime at random times. So even running the same compiled Java program in many different times could cause multiple results when multi threading is used.

The code will always start with:

int x = 0;
boolean bExit = false;

Then the threads are started, and madness begins. The statements could be analyzed in any order, and possibly pause at random times.X

Here are a list of the commands you used, with a number:

  1. x = 1;
  2. bExit = true;
  3. if (bExit == true) <- note that this is separate from the body of the if.
  4. System.out.println("x=" + x);

Threads are given runtime at random times. So even running the same compiled Java program in many different times will cause one of runtimes:

  • 1, 2, 3, 4. x is set to 1, bExit is set to true, then bExit is true so it prints "x=1"
  • 1, 3, 2. x is set to 1, bExit doesn't pass 3. (4 is therefore out of the stack), bExit then set to true.
  • 3, 1, 2. Fails conditional so skips 4, x set to 1, bExit set to true.

Basically you can't just put in an if statement in multi threaded programs and expect it to work as planned.

Improve this answer

4 Comments

The question was if you can get 2 3 4 1 and how that can happen.
@StenSoft Oh, thought it was a question over whether it can print at all.
@StenSoft I don't understand how one of these 3 cases that you show will print "x=0"
@DPM Neither of these three cases will show it but there are additional possible cases due to race (because of unsynchronized access) in the code.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.