It's probably fair to say that on the whole, the volatile keyword in Java is poorly documented, poorly understood, and rarely used. To make matters worse, its formal definition actually changed as of Java 5. On this and the following pages, we will cut through this mess and look at what the Java volatile keyword does and when it is used. We will also compare it to other mechanisms available in Java which perform similar functions but under subtly different other circumstances.
What is the Java volatile keyword?
Essentially, volatile is used to indicate that a variable's value will be modified by different threads.
Declaring a volatile Java variable means:
- The value of this variable will never be cached thread-locally: all reads and writes will go straight to "main memory";
- Access to the variable acts as though it is enclosed in a synchronized block, synchronized on itself.
We say "acts as though" in the second point, because to the programmer at least (and probably in most JVM implementations) there is no actual lock object involved. Here is how synchronized and volatile compare:
Characteristic | Synchronized | Volatile |
---|---|---|
Type of variable | Object | Object or primitive |
Null allowed? | No | Yes |
Can block? | Yes | No |
All cached variables synchronized on access? | Yes | From Java 5 onwards |
When synchronization happens | When you explicitly enter/exit asynchronized block | Whenever a volatile variable is accessed. |
Can be used to combined several operations into an atomic operation? | Yes | Pre-Java 5, no. Atomic get-set of volatiles possible in Java 5. |
Volatile variables in Java 5
We mentioned that in Java 5, the meaning of volatile has been tightened up. We'll come back to this issue in a moment. First, we'll look at a typical example of using volatile. Later, we'll look at topics such as:
- the tighter definition of volatile in Java 5;
- atomic updates to volatile variables, useful in concurrent programming and possible as of Java 5;
- a summary of when to use volatile, along with some typical Java bugs involving the volatile keyword.