Volatile Keyword in Java

Example of Volatile keywords in Java

The volatile keyword ensures that a variable’s value is always read from main memory, preventing thread caching issues. It is used in multi-threaded environments when a variable is accessed by multiple threads to ensure visibility and consistency. However, it does not provide atomicity.

Example:

• Java

Java

class SharedData {
    volatile boolean flag = false;
}

class Writer extends Thread {
    private SharedData data;
    
    public Writer(SharedData data) {
        this.data = data;
    }

    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        data.flag = true;
        System.out.println("Writer thread updated flag to true");
    }
}

class Reader extends Thread {
    private SharedData data;

    public Reader(SharedData data) {
        this.data = data;
    }

    public void run() {
        while (!data.flag) {
            // Busy waiting
        }
        System.out.println("Reader thread detected flag change");
    }
}

public class VolatileExample {
    public static void main(String[] args) {
        SharedData data = new SharedData();
        new Reader(data).start();
        new Writer(data).start();
    }
}

You can also try this code with Online Java Compiler

Run Code

Output:

Writer thread updated flag to true  
Reader thread detected flag change  

Usage of the Volatile Keyword

The volatile keyword in Java is mainly used in multithreaded programming to ensure visibility and consistency of shared variables across threads. When one thread updates a volatile variable, the new value is immediately visible to all other threads, preventing them from using stale or cached values.

Common Use Cases:

• Flags for stopping threads safely.
• Status indicators shared between threads.
• Single-check read scenarios (not suitable for full synchronization needs like atomicity).

Important Points About Java Volatile Keyword

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 behaviour.
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 fee main 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 the Java Volatile Keyword

The volatile keyword in Java provides several benefits when used in multi-threaded environments. Below are the key advantages:

1. Visibility: The volatile keyword ensures that any update to a volatile variable is immediately visible to all threads. It prevents stale data issues caused by CPU caching.

2. Thread Safety: It guarantees that multiple threads accessing a shared variable see the latest value, preventing race conditions. However, it does not ensure atomicity for compound operations.

3. Reordering Prevention: The volatile keyword prevents instruction reordering, ensuring that read and write operations execute in the correct order, maintaining the program’s intended behavior.

4. Lightweight Synchronization: Unlike synchronized, volatile does not involve lock acquisition, making it a faster alternative when only visibility and ordering are required.

5. Singleton Pattern Implementation: It is used in Double-Checked Locking for Singleton implementation to ensure proper instance visibility in a multi-threaded environment.

6. Non-Blocking Synchronization: It enables non-blocking synchronization, improving performance by allowing multiple threads to work without waiting for locks.

7. Debugging and Testing: volatile helps in debugging multi-threaded applications by ensuring that updates to variables are immediately reflected, making it easier to track concurrency-related issues.

Volatile vs Synchronized in Java

Limitations of the Volatile Keyword

While the volatile keyword in Java helps with visibility of shared variables across threads, it has important limitations:

• No Atomicity Guarantee:
  volatile does not make compound operations like increment (count++) atomic. For such cases, synchronization or atomic classes are required.
• No Mutual Exclusion:
  It does not provide locking, meaning multiple threads can still access and modify the variable simultaneously, potentially causing race conditions.
• Limited to Simple Flags or Single Variable Updates:
  volatile is suitable for simple status flags or variables but not for complex state management or multiple dependent variables.
• Does Not Replace Synchronization:
  It cannot be used as a complete alternative to synchronized blocks or methods when both visibility and atomicity are required.
• Cannot Guarantee Thread Safety in All Scenarios:
  For operations that require coordinated access or sequencing between threads, volatile alone is not sufficient.

Frequently Asked Questions

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 thread-safe in Java?

volatile ensures visibility of changes across threads but does not guarantee atomicity, so it is thread-safe only for simple variable reads and writes.

What is the purpose of volatile?

The purpose of volatile is to ensure that updates to a variable by one thread are immediately visible to other threads, avoiding cached stale values.

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.

Can we make an array volatile in Java?

In Java, you cannot make an entire array volatile. However, individual elements of an array can be declared volatile if they are reference types, ensuring changes are visible across threads.

What is the transient and volatile keyword in Java?

The transient keyword prevents a variable from being serialized, meaning it won’t be saved during the serialization process. The volatile keyword ensures that a variable's value is directly accessed from main memory, guaranteeing visibility across threads.

Conclusion

The volatile keyword in Java plays a crucial role in ensuring visibility and consistency of variable values across multiple threads. By guaranteeing that changes made to a volatile variable are immediately visible to all threads, it helps avoid subtle concurrency issues. However, it's important to note that volatile doesn't provide atomicity or synchronization, so for complex operations, additional synchronization mechanisms like synchronized blocks or Locks may still be necessary.

Recommended Readings:

• Transient Keyword in Java
• Difference between Atomic, Volatile, and Synchronized
• Difference between volatile and transient keywords in Java