The role of volatile in java: 1. Java provides the volatile keyword to ensure visibility; 2. To ensure orderliness, the code is [context = loadContext(); inited = true;]; 3. Provide double check.

The operating environment of this tutorial: windows7 system, java10 version, DELL G3 computer. This method is suitable for all brands of computers.

Related free learning recommendations: java basic tutorial

The role of volatile in java:

1. Visibility: Java provides the volatile keyword to ensure visibility.

When a shared variable is modified volatile, it will ensure that the modified value will be updated to the main memory immediately. When other threads need to read it, it will read the new value from the memory. .

Ordinary shared variables cannot guarantee visibility, because after an ordinary shared variable is modified, it is uncertain when it will be written to the main memory. When other threads read it, the memory may still be The original old value, so visibility is not guaranteed.

In addition, visibility can also be guaranteed through synchronized and Lock. Synchronized and Lock can ensure that only one thread acquires the lock at the same time and then executes the synchronization code, and the modification of the variable will be flushed to the main memory before releasing the lock. among. Visibility is therefore guaranteed.

Let’s look at a piece of code first. If thread 1 executes first and thread 2 executes later:

//線程1
boolean stop = false;
while(!stop){
doSomething();
}
//線程2
stop = true;

This code is a very typical piece of code. Many people may use this when interrupting a thread. Marking method. But in fact, will this code run completely correctly? That is, will the thread be interrupted? Not necessarily, maybe most of the time, this code can interrupt the thread, but it may also cause the thread to be unable to be interrupted (although this possibility is very small, but once this happens, it will cause an infinite loop).

The following explains why this code may cause the thread to be unable to be interrupted. As explained before, each thread has its own working memory during running, so when thread 1 is running, it will copy the value of the stop variable and put it in its own working memory.

Then when thread 2 changes the value of the stop variable, but before it has time to write it into the main memory, thread 2 switches to do other things, then thread 1 does not know the change of the stop variable by thread 2 , so the cycle will continue.

But after using volatile modification, it becomes different:

First: using the volatile keyword will force the modified value to be written to the main memory immediately;

Chapter 2: If the volatile keyword is used, when thread 2 makes a modification, the cache line of the cache variable stop in the working memory of thread 1 will be invalid (if reflected to the hardware layer, the corresponding cache line in the CPU's L1 or L2 cache will be invalid) );

Third: Since the cache line of the cache variable stop in the working memory of thread 1 is invalid, thread 1 will go to the main memory to read the value of the variable stop again.

Then when thread 2 modifies the stop value (of course, this includes 2 operations, modifying the value in the working memory of thread 2, and then writing the modified value into the memory), it will cause the working memory of thread 1 to The cache line of the cache variable stop is invalid, and then when thread 1 reads it, it finds that its cache line is invalid. It will wait for the main memory address corresponding to the cache line to be updated, and then go to the corresponding main memory to read the latest value.

Then what thread 1 reads is the latest correct value.

2. Ensure orderliness

volatile boolean inited = false;
//線程1:
context = loadContext(); 
inited = true; 
//線程2:
while(!inited ){
sleep()
}
doSomethingwithconfig(context);

Ensure that the context has been initialized.

3、double check

class Singleton{
private volatile static Singleton instance = null;
private Singleton() {
}
public static Singleton getInstance() {
if(instance==null) {
synchronized (Singleton.class) {
if(instance==null)
instance = new Singleton();
}
}
return instance;
}
}

The above is the detailed content of What is the role of volatile in java. For more information, please follow other related articles on the PHP Chinese website!