What is the role of volatile keyword in Java?

Preface

volatileis a keyword in Java that is used to modify variables. It provides the characteristics of visibility and prohibiting instruction rearrangement, but does not guarantee atomicity.

1. Visibility

• Question background:In a multi-threaded environment, each thread has its own working memory (such as CPU cache). The thread's read and write operations on shared variables may not be performed directly in the main memory, but in the working memory. This may cause one thread to modify the value of the shared variable, while other threads cannot see the modification, thus reading the expired value.
• The role of volatile :When a variable isvolatileWhen modified, it guarantees:
  • Write operation:When a thread is modifiedvolatileThe value of the variable, this new value will be immediately refreshed to the main memory.
  • Reading operation:When a thread readsvolatileWhen a variable is used, it will read the latest value from the main memory, rather than from its own working memory.
• Implementation principle: volatileVisibility is achieved through the Memory Barrier. A memory barrier is a CPU instruction that prevents the compiler and CPU from reordering the instructions and force data from working memory to or read from main memory.

Code example:

public class VolatileVisibilityExample {
    private static volatile boolean flag = false;
 // private static boolean flag = false; If volatile is not used, thread 1 may not be stopped
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            while (!flag) {
                // ... (Cycle to perform certain operations) ...            }
            ("Thread 1 stopped.");
        });

        Thread thread2 = new Thread(() -> {
            try {
                (1000); // Let thread1 execute first            } catch (InterruptedException e) {
                ();
            }
            flag = true; // Modify the value of flag            ("Thread 2 set flag to true.");
        });

        ();
        ();
    }
}

2. Prohibit Ordering

• Question background:To optimize performance, the compiler and CPU may reorder the execution order of instructions as long as it does not affect the execution results of a single-threaded program. However, in a multi-threaded environment, instruction reordering may cause unexpected behavior in the program.
• The role of volatile : volatileKeywords can prohibit specific types of instructions to reorder:
  • Read after writing:Can't be putvolatileThe write operation of variables is rearranged after the read operation.
  • Write after writing:Can't be putvolatileThe write operation of a variable is rearranged to anothervolatileAfter the variable write operation.
  • Read/write after reading:Can't be transferredvolatileReading of variables is rearranged to anothervolatileAfter the read or write operation of the variable.
• Implementation principle: volatileShield command reflow is prohibited by inserting a specific type of memory barrier. For example, involatileAfter the write operation of the variable, a StoreStore barrier will be inserted, and before the read operation, a LoadLoad barrier will be inserted, and a possible StoreLoad barrier will be inserted.
• Example of Double-Checked Locking: volatileOften used for double checking lock mode to prevent problems caused by instruction reordering.

  //Singleton Modepublic class Singleton{
      //Use volatile to prohibit the instruction reordering of instance = new Singleton()    private static volatile Singleton instance;
  
      private Singleton(){}
  
      public static Singleton getInstance(){
          if(instance == null){ //First check            synchronized(){
                  if(instance == null){ //The second check prevents multiple threads from passing the first check at the same time                    instance = new Singleton();
                  }
              }
          }
          return instance;
      }
  }
  

3. Atomicity is not guaranteed

• Important Note: volatileThe atomicity of the operation is not guaranteed. Atomicity refers to an operation that is indivisible, either executed in all or not, and there will be no execution.
• example: volatileSelf-increase operation of variables (i++) is not atomic. It actually consists of three steps: ReadiThe value of   williAdd the value of 1. Write the new value backi. In a multi-threaded environment, these three steps may be interrupted by other threads, resulting in an error in the result.
• **Solution: **If you need to ensure atomicity, you can usesynchronized、ReentrantLockor atomic class (such asAtomicInteger）。

Summarize:

• volatileKeywords are used to modify variables, provide visibility and prohibit instruction rearrangement.
• Visibility guarantee thread pairvolatileThe read and write operations of variables are performed directly in the main memory.
• Prohibit instruction re-arrangement to prevent compiler and CPU from matchingvolatileReorder variable-related instructions.
• volatileAtomicity is not guaranteed.
• volatileUsually used in scenarios such as status flags, double check locking, etc.

Problem analysis:

This question has been examined correctlyvolatileUnderstanding keywords includes its role, characteristics (visibility, prohibited instruction rearrangement) and limitations (not guaranteed atomicity). These concepts need to be explained clearly when answering, and some code examples are provided to illustrate the problem.

Contact knowledge points on other questions:

• What is Java Memory Model (JMM)? volatileis part of the Java Memory Model (JMM), which defines the interaction rules between threads and main memory.
• What are atomicity, visibility and order in Java? volatileVisibility and orderliness are provided (instruction rearrangement is prohibited), but atomicity is not guaranteed.
• What are the happens-before rules for Java? volatileWrite operation of variable happens-before The subsequent read operation of the variable.
• What is instruction reordering in Java? volatileSpecific types of instructions can be prohibited from re-arrangement.
• How is synchronized implemented in Java? synchronizedProvides atomicity, visibility and orderliness. In some cases,volatileCan be used assynchronizedA lightweight alternative to  (if only visibility and orderliness are required).
• Which atomic classes have you used in Java?Atomic class (such asAtomicInteger) provides atomic operations that can be used instead ofvolatile+ Extra synchronization scheme.
• Can the final keyword in Java ensure the visibility of variables?Final keywords can ensure visibility.

Understanding these connections can help you gain a more comprehensive understanding of Java concurrent programming and understand how to choose the right synchronization mechanism in practical applications.

This is the end of this article about what the role of volatile keywords in Java. For more related content of Java volatile keywords, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!