Detailed explanation of volatile usage

1. volatile The role of

1. Guaranteed visibility
2. There is no guarantee of atomicity
3. Prevent command rearrangement

2. Verification of visibility

class MyData{
    
	volatile int number = 0;
	public void addTo60(){
    
		thie.number = 60;
	}
}
public class VolatileDemo{
    
	public static void main(String[] args) {
    
		MyData myData = new MyData();
		new Thread(()->{
    
			try{
    TimeUnit.SECONDS.sleep(3);}catch(InterruptedException e){
    e.printStackTrace();}
			myData.addTo60();
		}, "AAA").start();
		while(myData.number == 0) {
    
			//  No addition volatile Always carry out this cycle , Because the upper thread changes the value ,main Threads don't know 
		}
	}
}

3. Verification of atomicity is not guaranteed

class MyData{
    
	volatile int number = 0;
	public void addTo60(){
    
		thie.number = 60;
	}
	public void addPlusPlus(){
    
		number++;
	}
	AtomicInteger atomicInteger = new AtomicInteger();
	public void addMyAtomic(){
    
		atomicInteger.getAndIncrement();
	}
}
public class VolatileDemo{
    
	public static void main(String[] args) {
    
		MyData myData = new MyData();
		for(int i = 0; i < 20; i++) {
    
			new Thread(() -> {
    
				for(int j = 1; j <= 1000; j++){
    
					myData.addPlusPlus();
					myData.addMyAtomic();
				}
			}, String.valueOf(i)).start();
		}
		//  Let the above thread execute later 
		while(Thread.activeCount() > 2) {
    
			Thead.yield();
		}
		System.out.println(myData.number); // volatile There is no guarantee of atomicity , So the final value is not 20000
		System.out.println(myData.atomicInteger ); //  You can guarantee atomicity , The value is 20000
	}
}

4. Prevent command rearrangement

1. The concept of instruction rearrangement ： When a computer is executing a program , To improve performance , Compilers and processors rearrange instructions .
   Source code ----> Compiler optimized rearrangement ----> A parallel rearrangement of instructions ----> Memory system rearrangement ----> The final instruction to be executed
2. Case study 1：

//  In the case of multithreading, instruction rearrangement occurs , May be 1234,2134,1324
public void mySort(){
    
	int x = 11; // sentence 1
	int y = 12; // sentence 2
	x = x + 5;  //  sentence 3
	y = x * x;  //  sentence 4
}

3. Case study 2：

int a, b, x, y = 0;
x = a; b = 1; // Threads 1
y = b; a = 2; // Threads 2
// x = 0, y = 0
// Possible execution after instruction rearrangement ：
b = 1; x = a; // Threads 1
a = 2; y = b; // Threads 2
// x= 2 y = 1