Shulou(Shulou.com)06/02 Report--

This article mainly explains "how to understand the Java memory model". The content in the article is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn "how to understand the Java memory model".

1. Why is it misunderstood?

First of all, let's analyze why many people, or even most people, will answer the wrong question.

I think there are several main reasons:

1. Java memory model, the word sounds too much like knowledge about memory distribution. It doesn't sound like it has anything to do with concurrent programming.

2. A lot of information on the Internet is wrong. Do not believe you to search the Internet "Java memory model", you will find that many people under the title of memory model, introduced the knowledge of JVM memory structure.

3. There is another situation, which is rare, but also exists. That is, many interviewers themselves think that the memory model is to introduce knowledge such as heap, stack, and method area. As a result, sometimes the interviewer doesn't know how to answer.

So, what exactly is the Java memory model? How should I answer this interview question?

two。 What is the memory model?

I have described the history of the Java memory model in detail in "if anyone asks you what the Java memory model is, send him this article". Let's review it again.

The Java memory model is translated from the English Java Memory Model (JMM). In fact, JMM is not as real as JVM memory structure. He is just an abstract concept.

Knowledge of the Java memory model is described in JSR-133: Java Memory Model and Thread Specification. JMM is related to multithreading, describing a set of rules or specifications that define that one thread's writing to a shared variable is visible to another thread.

Java memory model (Java Memory Model, JMM) is a mechanism and specification that conforms to the memory model specification, shields the access differences of various hardware and operating systems, and ensures the consistent effect of Java programs' access to memory on various platforms. The goal is to solve the problems of atomicity, visibility (cache consistency) and ordering when multithreads communicate through shared memory.

So, let's start with what is the so-called memory model specification, and what is atomicity, visibility, and ordering mentioned here?

Atomicity

Thread is the basic unit of CPU scheduling. CPU has the concept of time slice and will schedule threads according to different scheduling algorithms. So in a multithreaded scenario, atomicity problems occur. Because when a thread is performing a read-rewrite operation, after performing the read-write operation and running out of time slices, it will be asked to abandon the CPU and wait for rescheduling. In this case, reading and rewriting is not an atomic operation. That is, there is a problem of atomicity.

Cache consistency

In a multi-core CPU, multi-threaded scenario, each core has at least one L1 cache. If multiple threads access a shared memory in a process, and each thread executes on a different core, each core retains a buffer of shared memory in its own caehe. Because multiple cores can be parallel, multiple threads may write their respective caches at the same time, and the data may be different between the respective cache.

Adding cache between CPU and main memory may cause cache consistency in multi-threaded scenarios, that is, in multi-core CPU, the cache content of the same data may be inconsistent in each core's own cache.

Order

In addition to introducing time slices, due to processor optimization and instruction rearrangement, CPU may also execute input code out of order, for example, load- > add- > save may be optimized to load- > save- > add. This is the question of order.

The consistency problems caused by multi-CPU multi-level cache, the atomicity problems caused by CPU time slice mechanism, and the ordering problems caused by processor optimization and instruction rearrangement are all caused by continuous hardware upgrades. So, is there any mechanism that can solve the above problems well?

The simplest and most straightforward approach is to abolish processor and processor optimization techniques, abolish CPU caching, and let CPU interact directly with main memory. However, doing so can ensure the concurrency problem in multithreading. However, this is a bit of giving up eating for fear of choking.

Therefore, in order to ensure that atomicity, visibility and order can be satisfied in concurrent programming. There is an important concept, that is, the memory model.

In order to ensure the correctness of shared memory (visibility, order, atomicity), the memory model defines the specification of read and write behavior of multithreaded programs in shared memory system. These rules are used to regulate the read and write operation of memory, so as to ensure the correctness of instruction execution. It is processor-related, cache-related, concurrency-related, and compiler-related. It solves the memory access problems caused by CPU multi-level cache, processor optimization and instruction rearrangement, and ensures the consistency, atomicity and order in concurrent scenarios.

In order to solve the above problems, different operating systems have different solutions. In order to shield the underlying differences, Java language defines a set of memory model specification belonging to Java language, namely Java memory model.

The Java memory model stipulates that all variables are stored in the main memory, and each thread has its own working memory. The working memory of the thread keeps a copy of the main memory copy of the variables used in the thread. All the operations of the thread on the variables must be carried out in the working memory, and can not read or write the main memory directly. There is no direct access to variables in each other's working memory between different threads, and the transfer of variables between threads requires data synchronization between their own working memory and main memory.

JMM acts on the data synchronization process between working memory and main memory. He specifies how and when to synchronize data.

Implementation of 3.Java memory Model

Friends who know Java multithreading know that a series of keywords related to concurrent processing are provided in Java, such as volatile, synchronized, final, concurren package, and so on. In fact, these are some keywords that the Java memory model provides to programmers after encapsulating the underlying implementation.

When developing multithreaded code, we can directly use keywords such as synchronized to control concurrency, and we never need to care about the underlying compiler optimization, cache consistency and other issues. Therefore, the Java memory model, in addition to defining a set of specifications, also provides a series of primitives that encapsulate the underlying implementation for developers to use directly.

This article is not going to introduce the usage of all the keywords one by one, because there is a lot of information about the usage of each keyword on the Internet. Readers can learn by themselves. Another key point of this article is that we mentioned earlier that concurrent programming has to solve the problems of atomicity, orderliness, and consistency, so let's take a look at what methods are used to guarantee it in Java.

Atomicity

In Java, to ensure atomicity, two advanced bytecode instructions monitorenter and monitorexit are provided. In the article on the implementation principle of synchronized, it is introduced that the corresponding keyword of these two bytecodes in Java is synchronized.

Therefore, synchronized can be used in Java to ensure that operations within methods and code blocks are atomic.

Visibility

The Java memory model is realized by synchronizing the new value back to the main memory after the variable is modified and refreshing the variable value from the main memory before the variable is read, which depends on the main memory as the transmission medium.

The volatile keyword in Java provides a function that modifies variables that can be synchronized to main memory immediately after they are modified, and variables that are modified are refreshed from main memory before each use. Therefore, you can use volatile to ensure the visibility of variables in multithreaded operations.

In addition to the synchronized and final keywords in volatile,Java, visibility can also be achieved. It's just that it's implemented in a different way, and it's no longer unfolded here.

Order

In Java, synchronized and volatile can be used to ensure the order of operations between multiple threads. There are differences in how it is implemented:

The volatile keyword forbids instruction rearrangement. The synchronized keyword guarantees that only one thread is allowed to operate at a time.

Well, here's a brief introduction to the keywords that can be used to solve atomicity, visibility, and ordering in Java concurrent programming. Readers may find that, as if the synchronized keyword is * *, it can satisfy the above three features at the same time, which is actually the reason why many people abuse synchronized.

However, synchronized is relatively performance-sensitive, and although the compiler provides many lock optimization techniques, overuse is not recommended.

4. How to answer the interview

Earlier, I introduced some basics related to the Java memory model, but not all of them, because any knowledge point can be expanded, such as how volatile achieves visibility and how synchronized achieves orderliness.

However, the interviewer asks you: can you briefly introduce the memory model you understand?

First of all, check with the interviewer: by memory model, you mean JMM, which one is related to concurrent programming?

After getting an affirmative answer, start the introduction (if not, you may have to answer the heap, stack, and method area). . Embarrassed... Here you can also understand exactly what the interviewer wants to ask according to the context):

In fact, the Java memory model is a mechanism and specification that ensures that Java programs can access memory consistently on various platforms. The goal is to solve the problems of atomicity, visibility (cache consistency) and ordering when multithreads communicate through shared memory.

In addition, the Java memory model also provides a series of primitives that encapsulate the underlying implementation for developers to use directly. Such as some of our commonly used keywords: synchronized, volatile and concurrent packets.

That's all for the answer, and then the interviewer may continue to ask questions, and then continue to answer based on his questions.

So, when someone asks you about the Java memory model again, instead of answering the stack, method area, or even GC directly with one mouth, think about the interviewer's question below.

Thank you for your reading, the above is the content of "how to understand the Java memory model". After the study of this article, I believe you have a deeper understanding of how to understand the Java memory model, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.