volatile Keyword Usage and Examples

Learn about the Java volatile keyword with real-world examples. Understand how volatile ensures visibility in multi-threaded applications and when to use it.

This reference explains volatile Keyword Usage and Examples through its syntax, examples and boundaries. Use the linked course lessons when the surrounding Java concepts are unfamiliar.

In Java, the volatile keyword is used with variables to indicate that the value of a variable will be modified by different threads. It's a part of Java's memory management model and is crucial for safe access to shared variables in a concurrent application.

Java threads may cache variables locally to improve performance. However, this can lead to situations where one thread doesn't see the most recent value of a variable modified by another thread.

By declaring a variable volatile, we tell the JVM:

• Do not cache the value locally.
• Always read it from and write it to the main memory.

Let’s understand this with a simple example. Consider a boolean flag that controls whether a thread should continue running or not.

public class VolatileDemo extends Thread {
    private volatile boolean running = true;

    public void run() {
        System.out.println("Thread started...");
        while (running) {
            // do work
        }
        System.out.println("Thread stopped.");
    }

    public void stopThread() {
        running = false;
    }

    public static void main(String[] args) throws InterruptedException {
        VolatileDemo thread = new VolatileDemo();
        thread.start();

        Thread.sleep(1000);
        thread.stopThread(); // this will be seen by the other thread due to volatile
    }
}

Thread started...
Thread stopped.

If the running variable is not marked volatile, the thread might not stop as expected because it could be using a cached version of the variable that never sees the update.

• Visibility: Ensures the updated value is visible to all threads.
• No atomicity: It doesn’t make compound actions (like count++) atomic.
• No locking: Unlike synchronized, it doesn’t use locks, hence it's lightweight and faster.

• Flags for stopping threads.
• Status or state monitoring variables.
• Double-checked locking (used with care).

This demonstrates the difference volatile makes.

public class WithoutVolatile {
    private static boolean flag = false;

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (!flag) {
                // busy wait
            }
            System.out.println("Flag detected as true!");
        }).start();

        Thread.sleep(1000);
        flag = true; // may not be visible to other thread
    }
}

(no output - thread is stuck in infinite loop)

Now change flag to volatile and you’ll see:

Flag detected as true!

No. If you try to use volatile for increment operations like count++, it won't be thread-safe because ++ is not an atomic operation. Use AtomicInteger or synchronization instead.

private volatile int count = 0;

public void increment() {
    count++; // not thread-safe!
}

Check the example’s types, inputs and documented behavior before copying it into an application. Some APIs require external libraries, files or platform services; consult their setup notes.

Related explanations: Java Data Types - Primitive and Non-Primitive, Java Class - Blueprint of Objects, Exceptions in Java Introduction.

Supporting documentation: Official Java learning guide.