Volatile Keyword in Java

Last Updated: 14 July, 2023

In Java, the volatile keyword is used as a modifier for variables to ensure that their values are always read and written from/to the main memory, rather than relying on cached values stored in CPU registers or thread-local caches. It is primarily used for multithreaded programming to provide visibility and ordering guarantees.

When a variable is declared as volatile, any read or write operation on that variable will be atomic. This means that the variable's value will be consistent across different threads, and there will be no intermediate or partial results visible to other threads.

However, it's important to note that the volatile keyword does not provide mutual exclusion or lock semantics like the synchronized keyword or locks do. It only guarantees visibility and ordering.

Here's an example to illustrate the usage of the volatile keyword:

  public class VolatileExample {
    private volatile int counter = 0;
    
    public void incrementCounter() {
        counter++;
    }
    
    public int getCounter() {
        return counter;
    }
    
    public static void main(String[] args) {
        VolatileExample example = new VolatileExample();
        
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                example.incrementCounter();
            }
        });
        
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                int counterValue = example.getCounter();
            }
        });
        
        thread1.start();
        thread2.start();
        
        thread1.join();
        thread2.join();
        
        System.out.println(example.getCounter()); // should be 20000
    }
  }

In this example, the counter variable is declared as volatile. This ensures that all threads will see the most recent value of the counter variable, even if they are not actively reading it. As a result, the final value of the counter variable will be 20000, even though the two threads are incrementing it independently.

The volatile keyword is a powerful tool for ensuring visibility in multithreaded programming. However, it is important to remember that it does not guarantee atomicity. If we need to guarantee atomicity, we should use the synchronized keyword instead.

Volatile Keyword in Java

Currently No Video available