I'm reading about volatile keyword in Java and completely understand the theory part of it.
But, what I'm searching for is, a good case example, which shows what would happen if variable wasn't volatile and if it were.
Below code snippet doesn't work as expected (taken from here):
class Test extends Thread {
boolean keepRunning = true;
public void run() {
while (keepRunning) {
}
System.out.println("Thread terminated.");
}
public static void main(String[] args) throws InterruptedException {
Test t = new Test();
t.start();
Thread.sleep(1000);
t.keepRunning = false;
System.out.println("keepRunning set to false.");
}
}
Ideally, if keepRunning
wasn't volatile, thread should keep on running indefinitely. But, it does stop after few seconds.
I've got two basic questions:
- Can anyone explain volatile with example? Not with theory from JLS.
- Is volatile substitute for synchronization? Does it achieve atomicity?
Best Answer
Volatile --> Guarantees visibility and NOT atomicity
Synchronization (Locking) --> Guarantees visibility and atomicity (if done properly)
Volatile is not a substitute for synchronization
Use volatile only when you are updating the reference and not performing some other operations on it.
Example:
will not be thread safe without use of synchronization or AtomicInteger as incrementing is an compound operation.
Well that depends on various circumstances. In most cases JVM is smart enough to flush the contents.
Correct use of volatile discusses various possible uses of volatile. Using volatile correctly is tricky, I would say "When in doubt, Leave it out", use synchronized block instead.
Also:
synchronized block can be used in place of volatile but the inverse is not true.