一個解釋volatile關鍵字作用的最好的例子

閑話少敘，上代碼

package com.dwz.concurrency2.chapter3;

public class VolatileTest {
    private static volatile int INIT_VALUE = 0; 
    private static final int MAX_LIMIT = 5;
    
    public static void main(String[] args) {
        new Thread(() -> {
　　　　　　　//jvm自作多情的做了一個優化，當對一個變量只是讀操作的時候，只是訪問緩存的數據，只有進行寫操作的時候，會訪問主內存的數據
            int localValue = INIT_VALUE;
            while (localValue < MAX_LIMIT) {
                if(localValue != INIT_VALUE) {
                    System.out.printf("The value updated to [%d]\n", INIT_VALUE);
                    localValue = INIT_VALUE;
                }
            }
        }, "READER").start();
        
        new Thread(() -> {
            int localValue = INIT_VALUE;
            while (localValue < MAX_LIMIT) {
                System.out.printf("update the value to [%d]\n", ++localValue);
                INIT_VALUE = localValue;
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "UPDATER").start();
    }
}

測試結果，出現兩種情況：

1.INIT_VALUE被volatile關鍵字修飾時，READER線程是可以感知到UPDATER的變化

update the value to [1]
The value updated to [1]
update the value to [2]
The value updated to [2]
update the value to [3]
The value updated to [3]
update the value to [4]
The value updated to [4]
update the value to [5]
The value updated to [5]

2.INIT_VALUE缺少volatile關鍵字修飾時，READER線程感知不到UPDATER的變化

update the value to [1]
update the value to [2]
update the value to [3]
update the value to [4]
update the value to [5]

 volatile可以保證內存可見性，有序性，不讓jvm自作主張去優化，可以保證讀之前的寫操作完成，但是不能保證原子性

package com.dwz.concurrency2.chapter3;

public class VolatileTest2 {
    private static volatile int INIT_VALUE = 0; 
    private static final int MAX_LIMIT = 500;
    
    public static void main(String[] args) {
        new Thread(() -> {
            while (INIT_VALUE < MAX_LIMIT) {
                System.out.println("T1->" + (++INIT_VALUE));
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "ADDER-1").start();
        
        new Thread(() -> {
            while (INIT_VALUE < MAX_LIMIT) {
                System.out.println("T2->" + (++INIT_VALUE));
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "ADDER-2").start();
    }
}

測試結果：ADDER-1中的INIT_VALUE 和 ADDER-2中的INIT_VALUE會出現重復數據，因此volatile關鍵字是不能保證原子性的

volatile的使用場景
1.狀態量標記
volatile boolean start = true;
while(start) {

}

void close() {
start = false;
}
2.屏障前后的一致性

volatile關鍵字在多線程三個特性角度：
一旦一個共享變量被volatile修飾，具備以下含義：
1.保證了不同線程間的可見性
2.禁止對其進行重排序，也就是保證了有序性
3.並未保證原子性

volatile關鍵字實質：
1.保證重排序的時候不會把后面的指令放到屏障的前面，也不會把前面的放到后面
2.強制對緩存的修改操作會立刻寫入主存
3.如果是寫操作，它會導致其他CPU中的緩存失效