In-depth understanding of JAVA core memory model

In-depth understanding of the JAVA core memory model requires specific code examples

Concept analysis:
In programming, understanding the memory model is crucial. For JAVA developers, it is essential to understand and be familiar with the JAVA core memory model. Because understanding it can help developers write thread-safe code, thereby avoiding a series of thread-safety problems, such as Race Condition, deadlock, etc.

The JAVA core memory model is a set of specifications that describes how the JAVA virtual machine handles memory access rules for multi-threading. It specifies how threads interact with shared variables, including how to read variables from main memory to working memory and how to write variables from working memory back to main memory.

Example description:
In order to better understand the JAVA core memory model, here are several specific code examples to illustrate.

Example 1: Basic Concept Example

public class MemoryModelExample {
    private int num = 0;
    private boolean flag = false;

    public void writer() {
        num = 42;
        flag = true;
    }

    public void reader() {
        if (flag) {
            System.out.println("num: " + num);
        }
    }

    public static void main(String[] args) {
        final MemoryModelExample example = new MemoryModelExample();

        Thread writerThread = new Thread(new Runnable() {
            public void run() {
                example.writer();
            }
        });

        Thread readerThread = new Thread(new Runnable() {
            public void run() {
                example.reader();
            }
        });

        writerThread.start();
        readerThread.start();
    }
}

The above example shows a very simple thread safety issue, that is, the data visibility issue. First, the program creates a MemoryModelExample instance and starts a writing thread and a reading thread respectively. The writing thread sets the value of num to 42 and sets flag to true. The reading thread checks whether the flag is true, and if it is true, the value of num is output. If the memory model can ensure the visibility of data, you should be able to see the correct results in the reader42. However, due to the lack of synchronization measures, the output of this program is undefined and may output 0 or 42.

Example 2: Use volatile to ensure the visibility of data

public class MemoryModelExample {
    private volatile int num = 0;
    private volatile boolean flag = false;

    public void writer() {
        num = 42;
        flag = true;
    }

    public void reader() {
        if (flag) {
            System.out.println("num: " + num);
        }
    }

    public static void main(String[] args) {
        final MemoryModelExample example = new MemoryModelExample();

        Thread writerThread = new Thread(new Runnable() {
            public void run() {
                example.writer();
            }
        });

        Thread readerThread = new Thread(new Runnable() {
            public void run() {
                example.reader();
            }
        });

        writerThread.start();
        readerThread.start();
    }
}

By using the volatile keyword before num and flag, code example 2 ensures the visibility of the data. Even without other synchronization measures, the reader thread will always see the correct values ​​when reading num and flag.

Example 3: Use synchronized to ensure atomicity and orderliness

public class MemoryModelExample {
    private int counter = 0;

    public synchronized void increase() {
        counter++;
    }

    public synchronized void decrease() {
        counter--;
    }

    public void print() {
        System.out.println("counter: " + counter);
    }

    public static void main(String[] args) {
        final MemoryModelExample example = new MemoryModelExample();

        for (int i = 0; i < 10; i++) {
            Thread increaseThread = new Thread(new Runnable() {
                public void run() {
                    example.increase();
                }
            });

            Thread decreaseThread = new Thread(new Runnable() {
                public void run() {
                    example.decrease();
                }
            });

            increaseThread.start();
            decreaseThread.start();
        }

        example.print();
    }
}

In Example 3, by using the synchronized keyword to modify the increase() and decrease() methods, the counter variable is guaranteed to be The operations are atomic and ordered. Even if multiple threads access both methods at the same time, no race condition will occur. Finally, the final result is printed out through the print() method. You can see that no matter how many times it is run, the final result is 0.

Conclusion:
Through the above code examples, we can see that in the JAVA core memory model, using the volatile keyword can ensure visibility, while using the synchronized keyword can ensure atomicity and validity. sequence. When developers write multi-threaded code, they need to choose appropriate synchronization measures based on actual needs. Understanding the JAVA core memory model and practicing it with specific code examples can help us write more secure and reliable multi-threaded applications.

The above is the detailed content of In-depth understanding of JAVA core memory model. For more information, please follow other related articles on the PHP Chinese website!