Volatile Keyword in Java

Volatile vs Synchronized

When it comes to managing the state of variables in multi-threaded Java applications, two main keywords come into play: volatile & synchronized. Both are essential but serve different purposes.

Volatile

The volatile keyword is all about visibility. It tells the JVM (Java Virtual Machine) that a thread accessing a volatile variable must always merge its own private copy of the variable with the master copy in the main memory. This means that changes made by one thread are immediately visible to other threads. It's like a group of friends sharing a notepad. If one writes a new message on the notepad, everyone else can see it right away because there's only one notepad, and it's shared among all.

Here's a simple code snippet to demonstrate the use of volatile:

public class SharedObject {
    // Declare a volatile variable
    volatile int sharedCounter = 0;


    public void incrementCounter() {
        sharedCounter++;  // Directly updates the master copy
    }
}

Synchronized

On the other hand, synchronized is all about mutual exclusion. It ensures that only one thread can execute a block of code at a time. This is more like taking turns. Imagine a single bathroom that only one person can use at a time. When one person is using it, others have to wait their turn. This is what synchronized does; it makes sure that when one thread is working with a piece of code, no other thread can come in and mess things up.

Here's how you might use synchronized in a method:

public class Counter {
    private int count = 0;
 // Synchronized method to increment count
    public synchronized void incrementCount() {
        count++;  // Only one thread can execute this at a time
    }
}

While volatile ensures visibility of changes, synchronized also ensures atomicity (completeness) of operations. Using volatile is more lightweight compared to synchronized, which comes with a performance cost due to locking overhead. However, volatile cannot be used in all situations, especially when the operation involves more than one step (e.g., check-then-act operations). That's where synchronized or other synchronization techniques come into play.

Volatile in Java vs C/C++

Understanding the volatile keyword requires a bit of cross-language comparison, especially between Java & C/C++. While volatile exists in both Java and C/C++, its usage & implications differ slightly due to the nature of these languages and their memory models.

In Java, volatile is all about visibility & ordering. When a variable is declared as volatile in Java, it ensures that any thread that reads the variable will see the most recent write to that variable. It's a way to say, "Hey, this variable might be changed by other threads, so always go straight to the main memory to read its latest value." This guarantees a 'happens-before' relationship, meaning changes to a volatile variable are immediately visible to all other threads, and reads/writes to volatile variables cannot be reordered.

Example in Java

public class VolatileExample {
   // volatile variable
   
   volatile boolean keepRunning = true;
   
 public void runExample() {
       new Thread(() -> {
           int count = 0;
           while (keepRunning) {
               count++;
           }

           System.out.println("Thread finished. Counted up to " + count);

       }).start();

       // Main thread sleeps for a bit and then stops the loop

   try {
           Thread.sleep(100);

           keepRunning = false;

           System.out.println("Flag set to false.");

       } catch (InterruptedException e) {
           e.printStackTrace();
       }
   }
}

In C/C++, volatile is also used to indicate that a variable's value can change unexpectedly. However, in C/C++, it's more about preventing the compiler from optimizing away variable accesses. For instance, in embedded systems, certain memory-mapped peripheral registers need to be read or written in a specific order, and using volatile ensures the compiler won't reorder or optimize these accesses. This does not guarantee atomicity or visibility in the same way as in Java, especially considering C/C++'s more complex memory model and the lack of built-in thread memory model before C++11.

Example in C

#include <stdio.h>
volatile int flag = 0;

int main() {
   // Simulated peripheral register access
   
   while(flag == 0) {
       // Waiting for the flag to change
   }

   printf("Flag changed!\n");
   return 0;
}

In summary, while volatile serves a similar purpose in both Java & C/C++, the memory models & thread handling of these languages mean it plays out differently. In Java, it's part of the language's concurrency mechanism, providing a easy way to ensure visibility and ordering. In C/C++, it's more about telling the compiler to treat variable access, avoiding optimizations that could mess with the intended operation, especially in low-level programming contexts.

When to use volatile keywords?

1. Shared Variables: When a variable is shared between multiple threads and at least one thread modifies its value, declaring the variable as volatile ensures that all threads always see the most up-to-date value. This is particularly important when the variable is used for communication or synchronization between threads.

2. Visibility Guarantee: The volatile keyword guarantees that any write to a volatile variable is immediately visible to all other threads. This means that when one thread modifies the value of a volatile variable, other threads will see the updated value without any delay or inconsistency caused by caching.

3. Preventing Reordering: In Java, the compiler and the runtime are allowed to reorder certain operations for optimization purposes. However, when a variable is declared as volatile, the compiler and runtime are prohibited from reordering any read or write operations on that variable. This ensures that the operations on the volatile variable are executed in the order specified by the program.

4. Singleton Pattern: The volatile keyword is often used in the implementation of the Singleton pattern to ensure that only one instance of a class is created, even in a multi-threaded environment. Declaring the instance variable as volatile guarantees that all threads see the same instance of the Singleton class.

5. Non-Atomic Operations: When a variable is accessed and modified by multiple threads concurrently, and the operations on the variable are not atomic (i.e., they consist of multiple steps), using the volatile keyword can help prevent race conditions and ensure data consistency. However, it's important to note that volatility alone may not be sufficient for complex operations, and additional synchronization mechanisms like locks or atomic variables may be required.

Important Points

Let's discuss important points to keep in mind when using the volatile keyword in Java:

1. Visibility: The volatile keyword ensures that any write to a volatile variable is immediately visible to all other threads. This means that when one thread modifies the value of a volatile variable, other threads will see the updated value without any delay or inconsistency caused by caching.

2. No Atomicity: The volatile keyword does not provide atomicity for compound operations. If a variable requires both visibility and atomicity, additional synchronization mechanisms like locks or atomic variables should be used in conjunction with volatile.

3. Reordering Prevention: The volatile keyword prevents the compiler and runtime from reordering read and write operations on the volatile variable. This ensures that the operations are executed in the order specified by the program, maintaining the intended semantic behavior.

4. Performance Impact: Using the volatile keyword can have a performance impact because it forces the CPU to flush the cache and synchronize with the feemain memory more frequently. Therefore, it should be used judiciously and only when necessary to ensure thread safety and data consistency.

5. Not a Replacement for Synchronization: The volatile keyword is not a substitute for proper synchronization mechanisms like locks or synchronized methods. It should be used in specific scenarios where visibility and reordering prevention are required, but it does not provide mutual exclusion or synchronization between threads.

6. Variable Scope: The volatile keyword can be applied to instance variables, static variables, and array elements. It does not apply to local variables or method parameters, as they are not shared between threads.

7. Primitive Types and References: The volatile keyword can be used with both primitive types (such as int, boolean, etc.) and reference types. When used with reference types, it ensures the visibility of the reference itself, but not the state of the object it refers to.

8. Combine with Synchronized: In some cases, it may be necessary to use the volatile keyword in combination with synchronized blocks or methods to achieve both visibility and atomicity for complex operations or critical sections.

9. Singleton Pattern: The volatile keyword is often used in the implementation of the Singleton pattern to ensure that only one instance of a class is created, even in a multi-threaded environment. It guarantees that all threads see the same instance of the Singleton class.

10. Avoid Excessive Use: Using the volatile keyword excessively or unnecessarily can impact performance and make the code harder to reason about. It should be used selectively and only when the specific requirements of visibility and reordering prevention are needed.

Advantages of Volatile Keyword : 

The volatile keyword in Java offers several advantages when used appropriately in multi-threaded environments. Here are the main advantages of using the volatile keyword:

1. Visibility: The volatile keyword guarantees that any write to a volatile variable is immediately visible to all other threads. This means that when one thread modifies the value of a volatile variable, other threads will see the updated value without any delay or inconsistency caused by caching. This ensures that all threads have a consistent view of the variable's value, preventing stale or outdated data.

2. Thread Safety: By ensuring visibility, the volatile keyword helps in achieving thread safety. When multiple threads access a shared variable concurrently, using the volatile keyword prevents race conditions and ensures that the most up-to-date value of the variable is always visible to all threads. This is particularly important when the variable is used for communication or synchronization between threads.

3. Reordering Prevention: The volatile keyword prevents the compiler and runtime from reordering read and write operations on the volatile variable. In Java, the compiler and runtime are allowed to reorder certain operations for optimization purposes. However, when a variable is declared as volatile, the compiler and runtime are prohibited from reordering any read or write operations on that variable. This ensures that the operations on the volatile variable are executed in the order specified by the program, maintaining the intended semantic behavior.

4. Lightweight Synchronization: Using the volatile keyword provides a lightweight synchronization mechanism compared to other synchronization constructs like locks or synchronized methods. It does not involve the overhead of acquiring and releasing locks, making it more efficient in scenarios where only visibility and reordering prevention are required.

5. Singleton Pattern: The volatile keyword is often used in the implementation of the Singleton pattern to ensure that only one instance of a class is created, even in a multi-threaded environment. Declaring the instance variable as volatile guarantees that all threads see the same instance of the Singleton class, preventing multiple instances from being created due to inconsistent caching.

6. Non-Blocking Synchronization: The volatile keyword enables non-blocking synchronization, where threads can continue execution without being blocked while waiting for access to a shared resource. This can lead to improved performance and scalability in certain scenarios, as threads can make progress independently.

7. Debugging and Testing: Using the volatile keyword can aid in debugging and testing multi-threaded applications. It ensures that the changes made to a volatile variable are immediately visible to other threads, making it easier to identify and diagnose issues related to thread communication and synchronization.

Frequently Asked Questions

Is shared memory volatile?

No, shared memory is not inherently volatile. Volatile is a keyword used to ensure visibility and prevent reordering of variable access.

Where is the volatile keyword used?

The volatile keyword is used to declare variables that are shared and accessed by multiple threads in a multi-threaded environment.

Why is volatile memory needed?

Volatile memory is needed to store data that requires fast access and does not need to be retained when power is lost.

Is volatile in Java more efficient than synchronized?

Yes, volatile is generally more efficient than synchronized because it doesn't involve locking. However, its use cases are more limited. If you only need to ensure visibility and don't need atomicity for multi-step operations, volatile can be a more performant choice.
 

Conclusion

In this article, we learned the importance and use of the volatile keyword in Java, contrasting it with synchronized and exploring its similarities and differences with its usage in C/C++. We started with a basic understanding of what volatile means in Java - ensuring visibility of changes to variables across threads without the need for synchronization mechanisms like locking. We then compared volatile with synchronized, highlighting that volatile is best for simple flag-like variables, while synchronized is needed for more complex operations involving multiple steps or variables.

You can refer to our guided paths on the Coding Ninjas. You can check our course to learn more about DSA, DBMS, Competitive Programming, Python, Java, JavaScript, etc. Also, check out some of the Guided Paths on topics such as Data Structure and Algorithms, Competitive Programming, Operating Systems, Computer Networks, DBMS, System Design, etc., as well as some Contests, Test Series, and Interview Experiences curated by top Industry Experts.