Threads: Busy Waiting - Empty While-Loop [duplicate]

Answer 1

In addition to everything said in this other answer (just substitute your hasToWait for finished in that answer), the reason why the code starts working when you add a println is as follows:

• println is a synchronized method;
• you call it in both threads;
• this creates a happens-before relationship between the two threads;
• therefore the write to the boolean flag becomes visible to the child thread.

You could say that it starts working mostly by accident: you are piggybacking on the synchronization going on in println.

Answer 2

The real problem with your code is the instance field hasToWait. This field is being used by two threads. The car thread reads the value, and the traffic light thread updates the value after some time.

The access to this field must be synchronized in some way.

There are two ways to do this:

1. Use the synchronized keyword. Either by using a synchronized block at all places, where it is read or written, or - better - write a synchronized getter and a synchronized setter, then use the getter and the setter inside the Car class.

2. Use the volatile keyword. Just declare your field as volatile. This keyword exists for exactly that case. More information on volatile can be found in Oracle's Java Tutorials.

After reading the article about atomic access (see link above), it should be clear that option 2 (declaring volatile) is the far better option - for this use case.

Now to the difference you see between your computer and your professor's computer: As long as you are using a single-core-processor, you will see updates on an instance field in other threads as though they were synchronized, because the CPU does not have to synchronize these values in the other cores' cache areas. If you use a multi-core-processor, then the JVM is able to run threads on several cores. That means, that these cores have to synchronize values, and the volatile mechanism is exactly designed for that.