Code analysis of Java volatile keyword

The content of this article is about the code analysis of Java volatile keyword. It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

I believe that most Java programmers have learned how to use the volatile keyword. The definition of volatile on Baidu Encyclopedia:

volatile is a type modifier (type specifier) ​​designed to modify variables that are accessed and modified by different threads. volatile functions as an instruction keyword to ensure that this instruction will not be omitted due to compiler optimization and requires direct reading of the value each time.

There may be many friends who have just learned Java who still feel confused after reading the very general description above.

Below we will use a specific example to learn the usage of volatile.

Look at this example:

public class ThreadVerify {
    public static Boolean stop = false;
    public static void main(String args[]) throws InterruptedException {
        Thread testThread = new Thread(){
            @Override
            public void run(){
                int i = 1;
                while(!stop){
                    //System.out.println("in thread: " + Thread.currentThread() + " i: " + i);
                    i++;
                }
                System.out.println("Thread stop i="+ i);
            }
        }
        ;
        testThread.start();
        Thread.sleep(1000);
        stop = true;
        System.out.println("now, in main thread stop is: " + stop);
        testThread.join();
    }
}

This code defines a Boolean variable stop in the second line of the main thread, and then the main thread starts a new thread and keeps increasing the counter in the thread. The value of i will not end the loop until the Boolean variable stop of the main thread is set to true by the main thread.

The main thread uses Thread.sleep to pause for 1 second and then set the Boolean value stop to true.

Therefore, the result we expect is that the above Java code stops after executing for 1 second, and prints out the actual value of counter i within 1 second value.

However, after executing this Java application, you find that it enters an infinite loop, and you find in the task manager that the CPU usage of this Java program soars.

what is the reason? Let us review the memory model knowledge taught in the computer major course Operating Systems.

Take the Java memory model as an example. The Java memory model is divided into main memory (main memory) and work memory (work memory). The variables in the main memory are shared by all threads. Each thread has its own working memory, and the variables inside include thread-local variables. If a variable in main memory is used by a thread, the thread's working memory will maintain a copy of the main memory variable.

All read and write operations by a thread on variables must be performed in the working memory, and variables in the main memory cannot be directly manipulated. Different threads cannot directly access each other's working memory. The transfer of variables between threads needs to be completed through main memory. The interactive relationship between threads, main memory, and working memory is as follows:

If the thread modifies the definition in its own execution code, Variables in the main thread (main memory) are modified directly in the thread's working memory, and then at a certain moment (the Java programmer cannot control this moment, but is scheduled by the JVM), this modification is written back from the working memory. main memory.

Back to our example. Although the main thread modifies the stop variable, it only modifies the value in the main memory, while the stop variable in the working memory of the thread that operates the counter still has the old value, which is always false. Therefore this thread is stuck in an infinite loop.

Once you know the principle, the solution is simple. Add the keyword volatile before the stop variable to modify it, so that every time the stop value is read in the counter thread, volatile will force the thread to read from the main memory instead of reading from the working memory of the current thread. This avoids an infinite loop. The picture below shows that after 1 second, the counter has executed 1.4 billion times.

The above is the detailed content of Code analysis of Java volatile keyword. For more information, please follow other related articles on the PHP Chinese website!