Volatile Keyword In Java | Syntax, Working, Uses & More (+Examples)

13 mins read

The volatile keyword in Java might sound a bit intimidating, but it’s actually a simple tool to help make your programs thread-safe. Imagine two or more people trying to share the same notebook—it can get messy if they don’t see the latest changes! Similarly, volatile ensures that every thread in your program sees the most up-to-date value of a shared variable. 

In this article, we’ll break down what volatile does, how it works, best practices for its use, and provide examples you can easily understand. By the end, you’ll see how it helps keep your programs running smoothly, without unexpected behavior!

What Is The Volatile Keyword In Java?

The volatile keyword is a modifier in Java programming that is used with variables to ensure their visibility across threads. A volatile variable is always read from and written to the main memory, bypassing the thread's local cache. This is important in multithreaded programming, where different threads might be accessing and modifying the same variable. The volatile keyword ensures that any changes made to the variable by one thread are immediately visible to other threads.

Syntax Of Volatile Keyword In Java

volatile dataType variableName;

Here: 

• volatile: It is a keyword that ensures visibility of updates across threads.
• dataType: It represents the data type of the variable.
• variableName: It is the name of the variable.

Real-Life Example To Understand This Better:

Imagine you have two threads in a program. One thread is responsible for updating a flag, and the other thread needs to check this flag to decide whether it should keep running or stop. 

• Without volatile, the thread that checks the flag may not see the updated value because of caching in each thread. This could lead to the thread checking the flag repeatedly and not noticing the change made by the other thread.
• With the volatile keyword, when one thread changes the value of the flag, the update is immediately visible to the other thread. This ensures that the second thread always reads the most recent value.

How Does Volatile Keyword In Java Work?

The volatile keyword in Java works by ensuring visibility and ordering of variable updates across threads:

• Ensures Visibility: Changes to a volatile variable by one thread are immediately visible to all other threads. Threads read the value directly from main memory instead of using cached copies.
• Prevents Caching: The variable is not stored in thread-local caches, ensuring all threads work with the same value.
• Establishes a Happens-Before Relationship: A write to a volatile variable happens-before any subsequent reads of that variable by other threads. This ensures a consistent order of operations.
• Prevents Instruction Reordering: The compiler and CPU are prevented from reordering instructions involving volatile variables. This guarantees predictable behavior in multithreaded programs.
• Does Not Ensure Atomicity: The volatile keyword in Java does not make compound actions (e.g., counter++) atomic. Use synchronization for such operations to avoid race conditions.
• Use Case: Ideal for flags, status indicators, and variables shared across threads where only visibility (not atomicity) is required.

Explore this amazing course and master all the key concepts of Java programming effortlessly!

Using Volatile Keyword In Java To Control Thread Execution

Here’s a simple example demonstrating the use of the volatile keyword in Java for controlling thread execution:

Code Example: 

public class VolatileExample {

    private volatile boolean stopRequested = false;

    public void start() {
        new Thread(() -> {
            while (!stopRequested) {
                // Do some work
            }
        }).start();
    }

    public void stop() {
        stopRequested = true;
    }
}

Output: 

The code itself doesn't directly produce any visible output. Its primary purpose is to create and manage a thread that runs until a stopRequested flag is set to true.

Explanation: 

In the above code example-

1. First, in the VolatileExample class, we declare a volatile boolean variable stopRequested, initially set to false.
2. The start() method creates a new thread that continuously checks the value of stopRequested in a while loop. As long as stopRequested remains false, the thread keeps executing some work (represented by a comment).
3. The stop() method sets stopRequested to true, signaling the thread to stop its execution.
4. The volatile keyword ensures that any update to stopRequested made by one thread (such as calling stop()) is immediately visible to the other thread (which is checking stopRequested), allowing the thread to exit the loop and stop its work.

Using Volatile Keyword In Java To Signal Between Multiple Threads

Here’s a simple example demonstrating how the volatile keyword is used to signal between multiple threads in Java.

Code Example: 

public class VolatileExample {

    // Declare a volatile variable
    private static volatile boolean flag = false;

    public static void main(String[] args) throws InterruptedException {

        // Thread 1: Sets the flag to true after some delay
        Thread thread1 = new Thread(() -> {
            try {
                Thread.sleep(1000); // Simulate some work
                flag = true; // Set flag to true
                System.out.println("Flag set to true by Thread 1");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // Thread 2: Checks the flag and reacts when it becomes true
        Thread thread2 = new Thread(() -> {
            while (!flag) {
                // Busy-wait until the flag is set to true
            }
            System.out.println("Flag checked by Thread 2: Flag is now " + flag);
        });

        // Start both threads
        thread1.start();
        thread2.start();

        // Wait for both threads to finish
        thread1.join();
        thread2.join();
    }
}

Output (set code file name as VolatileExample.java): 

Flag set to true by Thread 1
Flag checked by Thread 2: Flag is now true

Explanation: 

In the above code example-

1. We declare a volatile boolean variable flag to ensure that its value is consistently visible to all threads.
2. In the main() method, we create and start two threads:
• Thread 1 simulates some work by sleeping for 1000 milliseconds. After that, it sets flag to true and prints a message indicating that the flag has been set.
• Thread 2 enters a busy-wait loop, repeatedly checking the value of flag. It continues waiting until flag becomes true, at which point it prints a message showing that the flag is now true.
3. Both threads are started using start() function, and then we use join() to ensure that the main thread waits for both threads to finish before completing the program.
4. The volatile keyword ensures that when flag is set to true by Thread 1, Thread 2 immediately sees the change and exits the loop, allowing it to print the updated flag value.

Sharpen your coding skills with Unstop's 100-Day Coding Sprint and compete now for a top spot on the leaderboard!

Difference Between Synchronization And Volatile Keyword

Both the synchronization and volatile keywords play crucial roles in Java’s multithreading environment, but they serve different purposes. While synchronization ensures thread safety for complex operations by providing mutual exclusion, the volatile keyword guarantees visibility of changes to variables across threads without the overhead of locking.

Here's a detailed comparison between the synchronization and volatile keywords in Java:

Code Example:

// Using Synchronization
class SharedResource {
    private int counter = 0;

    public synchronized void increment() {
        counter++;  // Thread-safe increment due to synchronization
    }

    public synchronized int getCounter() {
        return counter;
    }
}

// Using Volatile
class SharedFlag {
    private volatile boolean flag = false;

    public void setFlag() {
        flag = true;  // Immediate visibility to other threads
    }

    public boolean checkFlag() {
        return flag;  // Always reads the latest value of flag
    }
}

Output: 

There are no actual threads or method calls in the code itself, so it does not directly produce any output.

Explanation: 

In the above code example-

1. We have a private integer variable counter in the SharedResource class that is initialized to 0.
2. We then mark the increment() method as synchronized, ensuring that only one thread can execute it at a time, preventing concurrent modifications to the counter.
3. Inside the synchronized method, the counter is incremented safely, making it thread-safe.
4. The getCounter() method is also synchronized, allowing only one thread to access the counter's value at a time, ensuring consistency when reading the value.
5. Now, in the SharedFlag class, we have a private boolean variable flag that is marked as volatile.
6. The setFlag() method sets flag to true, and the volatile keyword ensures that this change is immediately visible to all threads, preventing caching of the variable in thread-local memory.
7. The checkFlag() method always returns the latest value of flag, as it directly reads from the main memory, ensuring consistency across threads.

Common Mistakes And Best Practices While Using Volatile Keyword In Java

Here are some common mistakes and best practices when using the volatile keyword in Java:

Common Mistakes:

• Using volatile for Complex Synchronization:The volatile ensures visibility but does not guarantee atomicity, so using it for complex operations like incrementing a counter can lead to race conditions. For Example-

private volatile int counter = 0;
counter++; // Not atomic, could lead to race conditions

• Assuming volatile Handles Thread Communication: The volatile only ensures visibility, not proper coordination or mutual exclusion. For inter-thread communication, additional mechanisms like wait(), notify(), or synchronized blocks are necessary.
• Believing volatile Makes All Operations Thread-Safe: The volatile ensures that the value of a variable is visible across threads, but it doesn't guarantee thread safety for complex operations (e.g., checking and updating a variable together).
• Using volatile for Non-Primitive Types: The volatile can be used with primitive types or references to simple objects, but not with complex objects. It does not ensure atomicity for mutable objects like collections. For Example-

private volatile MyObject obj; // obj may still not be thread-safe

• Misunderstanding volatile Semantics: The volatile only affects visibility. It doesn’t synchronize access to a variable, leading to potential issues if combined with other operations on the variable. For Example-

private volatile boolean flag;
// The flag being volatile ensures visibility, but not atomic updates like checking and setting it together.

Best Practices:

• Use volatile for Simple Variables: Use volatile for flags or state indicators (like boolean, int, etc.) that are only read or written in simple operations. For Example-

private volatile boolean flag = false;

• Use Atomic Classes for Non-Atomic Operations: For operations like increments or complex reads and writes, prefer atomic classes like AtomicInteger from java.util.concurrent.atomic. For Example-

private AtomicInteger counter = new AtomicInteger(0);
counter.incrementAndGet(); // Atomic operation

• Combine volatile with Proper Synchronization: Use volatile in combination with synchronized blocks or Locks for thread safety when performing complex operations on shared data. For Example-

private volatile boolean flag = false;
public synchronized void toggleFlag() {
    flag = !flag;
}

• Avoid volatile for Complex Object Synchronization: For mutable objects (e.g., collections), use synchronization mechanisms like synchronized or Lock to ensure thread safety, rather than volatile. For Example-

private final List<String> list = new ArrayList<>();
public synchronized void addToList(String item) {
    list.add(item); // Use synchronization for complex objects
}

• Use volatile for Flags or State Indicators: The best use of volatile is for simple flags that indicate thread execution status or cancellation, ensuring immediate visibility across threads. For Example-

private volatile boolean stopRequested = false;

• Ensure Proper Visibility Across Threads: Remember that volatile ensures visibility of the variable’s latest value but does not manage atomicity or mutual exclusion, so use it when only visibility is needed.

Are you looking for someone to answer all your programming-related queries? Let's find the perfect mentor here.

Conclusion

The volatile keyword is a valuable tool for maintaining visibility and consistency of shared variables in multithreaded Java applications. However, it is not a silver bullet. While it addresses visibility issues, it falls short in providing atomicity and coordination. Use it wisely for simple use cases like flags or status variables, and combine it with synchronization mechanisms for more complex scenarios. By understanding its strengths and limitations, you can write safer and more efficient multithreaded code in Java.

Frequently Asked Questions

Q. What is the volatile keyword in Java, and when should it be used?

The volatile keyword in Java is used to ensure that a variable’s value is always visible to all threads. When a variable is declared as volatile, any read or write operation on that variable is directly performed on the main memory rather than cached in local thread memory. This is particularly useful in multithreaded programming when one thread modifies a variable and other threads need to see the latest value.

When to use: You should use volatile for flags or state variables where visibility is critical (e.g., flags to stop threads, shared status variables).

Q. Does volatile guarantee thread safety in Java?

No, volatile does not guarantee thread safety. It only ensures that changes made to a volatile variable are visible across all threads. However, it does not ensure atomicity. For example, incrementing a volatile counter (counter++) is not atomic, and it can still lead to race conditions.

Thread safety: To ensure thread safety for complex operations (e.g., incrementing a counter, checking and updating a value), you should use synchronization or atomic classes like AtomicInteger from java.util.concurrent.atomic.

Q. Can volatile be used for all types of variables in Java?

While volatile can be used with primitive data types (int, boolean, etc.) and object references, it is not suitable for complex data types or mutable objects like collections or user-defined objects.

Limitations: For complex or mutable objects, using volatile does not ensure atomicity or thread safety for object manipulations. In these cases, you should rely on synchronization (e.g., synchronized blocks or Lock objects) to manage thread-safe access to the object.

Q. What is the difference between volatile and synchronized in Java?

• Volatile: Guarantees visibility of changes to a variable across threads but does not guarantee atomicity or thread safety for composite operations. It is suitable for simple flags or state indicators.
• Synchronized: Ensures that only one thread at a time can access the synchronized block or method, providing mutual exclusion. It also guarantees visibility of changes, along with atomicity.
• Use case: Use volatile for flags or simple variables and synchronized for more complex operations where atomicity is required (e.g., read-modify-write operations).

Q. What happens if I use volatile incorrectly in Java?

Using volatile incorrectly can lead to subtle bugs. For instance, it does not solve the problem of thread synchronization for composite operations or mutable objects. If you use it for non-atomic operations, such as incrementing a counter (counter++), it can result in race conditions, leading to inconsistent or incorrect values.

Example: Using volatile on a counter or performing a complex calculation will not guarantee that the operation is atomic or thread-safe. For such operations, consider using AtomicInteger or synchronizing the method.

Q. How does the volatile keyword work with multiple threads in Java?

When a variable is marked as volatile, any write to that variable by one thread is immediately visible to other threads. This ensures that each thread accesses the most recent value of the variable, avoiding inconsistencies due to local caches.

Usage in multi-threading: The volatile keyword in Java is often used for controlling thread execution, signaling between threads (e.g., flags for stopping threads), and ensuring immediate visibility of updates without synchronization. However, it does not synchronize access to the variable, so it is not suitable for complex operations that require atomicity or mutual exclusion.

With this, we conclude our discussion on the volatile keyword in Java. Here are a few other topics that you might be interested in reading: 

1. 15 Popular JAVA Frameworks Use In 2023
2. What Is Scalability Testing? How Do You Test Application Scalability?
3. Top 50+ Java Collections Interview Questions
4. 10 Best Books On Java In 2024 For Successful Coders
5. Difference Between Java And JavaScript Explained In Detail
6. Top 15+ Difference Between C++ And Java Explained! (+Similarities)