The volatile keyword in Java

In Java, the volatile keyword is used to declare a variable as "volatile." When applied to a variable, the volatile keyword guarantees that any thread accessing the variable will always see the most up-to-date value of that variable, ensuring visibility across threads.

Volatile keyword

When a variable is declared as volatile, it serves as a hint to the Java Virtual Machine (JVM) that the variable may be accessed by multiple threads simultaneously and should not be cached in CPU registers or thread-local caches. Instead, the value of the variable is always read from and written to the main memory.

class VolatileExample { private volatile int counter = 0; public void incrementCounter() { counter++; } public void printCounter() { System.out.println(counter); } }

In this code, the counter variable is declared as volatile. This means that when one thread increments the counter, the change will be reflected in the counter variable in all other threads immediately.

To see how this works, let's run the following code:

public class VolatileTest { public static void main(String[] args) { VolatileExample example = new VolatileExample(); Thread thread1 = new Thread(new Runnable() { @Override public void run() { for (int i = 0; i < 1000; i++) { example.incrementCounter(); } } }); Thread thread2 = new Thread(new Runnable() { @Override public void run() { for (int i = 0; i < 1000; i++) { example.printCounter(); } } }); thread1.start(); thread2.start(); thread1.join(); thread2.join(); } }

This code will create two threads, one that increments the counter and one that prints the counter. If the counter variable was not declared as volatile, it is possible that the printCounter() method would sometimes print a value of the counter that is less than 1000, even though the incrementCounter() method has been called 1000 times. This is because the counter variable could be cached in the CPU registers of each thread, and the change to the counter variable made by the incrementCounter() method would not be reflected in the cached copy of the variable.

However, because the counter variable is declared as volatile, the printCounter() method will always print the most up-to-date value of the counter variable. This is because the printCounter() method will always read the value of the counter variable directly from main memory, bypassing the CPU registers.

Use of volatile keyword

The use of the volatile keyword provides two main guarantees: visibility and atomicity.

  1. Visibility: When a variable is declared as volatile, any changes made to its value by one thread are immediately visible to all other threads. This ensures that all threads accessing the variable will see the most recent value, even if it was modified by a different thread.
  2. Atomicity: While volatile ensures visibility, it does not guarantee atomicity by itself. Atomicity refers to the property of an operation being performed as a single, indivisible unit. Volatile variables are not atomic for compound operations, such as incrementing a counter. For operations that require atomicity, the atomic classes provided in the java.util.concurrent.atomic package should be used instead.

The usage of the volatile keyword should be limited to cases where variables are shared between threads, and simple read and write operations need to be synchronized in terms of visibility. It is particularly useful in scenarios where a variable is updated by one thread and read by another without any additional synchronization mechanisms.


The volatile keyword is a powerful tool that can be used to ensure that multiple threads see the most up-to-date value of a variable. However, it is important to use it correctly and to understand its limitations.