The reserved word volatile in Java and its difference from synchronized

1. Locks provide two main features: mutual exclusion and visibility. Mutual exclusion allows only one thread to hold a specific lock at a time, so you can use this feature to implement a coordinated access protocol to shared data, so that only one thread can use the shared data at a time. Visibility is more complex, and must ensure that changes made to the shared data before the lock is released are visible to another thread that subsequently acquires the lock - without the visibility guarantee provided by the synchronization mechanism, what the thread sees Shared variables may have previous values ​​or inconsistent values, which can lead to many serious problems.

2.

In Java, in order to ensure data consistency when multi-threads read and write data, two methods can be used:

Synchronization

For example, using the synchronized keyword, or using a lock object.

volatile

Use the volatile keyword
Summarize volatile in one sentence, which allows other threads to know as soon as possible when the value of a variable changes.

Detailed explanation of volatile

First of all, we must first realize that there is such a phenomenon, compile In order to speed up the running of the program, the write operation of some variables will first be performed on the register or CPU cache, and finally written to the memory.
In this process, the new value of the variable is invisible to other threads. And The function of volatile is that the read and write operations of the variables it modifies must be performed in memory!

volatile and synchronized

The essence of volatile is to tell the jvm that the value of the current variable in the register is uncertain and needs to be read from the main memory When reading, synchronized locks the current variable. Only the current thread can access the variable, and other threads are blocked.
volatile can only be used at the variable level, while synchronized can be used in variables and methods.
volatile can only implement variables Modify visibility, but does not have atomic characteristics, while synchronized can guarantee the modification visibility and atomicity of variables.
volatile will not cause thread blocking, while synchronized may cause thread blocking.
Volatiles marked with volatile will not be blocked Compiler optimization, and variables marked with synchronized can be optimized by the compiler.

3. Therefore, be careful when using the volatile keyword. It does not mean that as long as a simple type variable is modified with volatile, all operations on this variable are the original operations. , when the value of the variable is determined by its previous value, such as n=n+1, n++, etc., the volatile keyword will be invalid. Only when the value of the variable has nothing to do with its previous value, the operation on the variable is atomic. , such as n = m + 1, this is the original level. Therefore, you must be cautious when using volatile keys. If you are not sure, you can use synchronized instead of volatile.

Summary: The essence of volatile is to tell the JVM that the value of the current variable in the register is uncertain and needs to be read from main memory. Some effects of synchronized can be achieved, but when n=n+1, n++, etc., the volatile keyword will be invalid and cannot achieve the same thread synchronization effect as synchronized.