代碼在寫入 volatile 修飾的變量的時候

        改變線程工作內(nèi)存中volatile變量副本的值

        將改變后的副本的值從工作內(nèi)存刷新到主內(nèi)存

代碼在讀取 volatile 修飾的變量的時候

        從主內(nèi)存中讀取volatile變量的最新值到線程的工作內(nèi)存中

        從工作內(nèi)存中讀取volatile變量的副本

 static class Counter{
        public int flag = 0;
    }
    
    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread t1 = new Thread(){
            @Override
            public void run() {
                while (counter.flag == 0){
 
                }
                System.out.println("循環(huán)結(jié)束");
            }
        };
        t1.start();
        Thread t2 = new Thread(){
                Scanner scanner = new Scanner(System.in);
                System.out.println("請輸入一個整數(shù)：");
                counter.flag = scanner.nextInt();
        t2.start();

預(yù)期的結(jié)果是：

線程1會先進(jìn)入循環(huán)狀態(tài)，線程2讀取一個用戶輸入的整數(shù)。隨著用戶的輸入一個非0的整數(shù)之后，線程1就會終止。

實(shí)際效果：

線程2輸入完畢后，線程1循環(huán)并未結(jié)束

2，編譯器優(yōu)化問題

線程1的核心代碼中，循環(huán)其實(shí)啥也沒干，反復(fù)快速的執(zhí)行循環(huán)條件中的比較操作。

先從內(nèi)存中讀取flag的值到CPU中

在CPU中比較這個值和0的關(guān)系

編譯器判定這個邏輯中循環(huán)沒有干啥事，只是頻繁的讀取內(nèi)存而已，于是編譯器就把讀內(nèi)存的操作優(yōu)化了，第一次把內(nèi)存中的數(shù)據(jù)督讀到CPU之后，后序的內(nèi)存并不是真正的從內(nèi)存中讀，而是直接從剛在的CPU中讀數(shù)據(jù)

編譯器認(rèn)為flag沒有改動，其實(shí)只是在當(dāng)前線程中沒有改動，編譯器就不能感知到其他的線程對flag進(jìn)行了修改

static class Counter{
        public  volatile  int flag = 0;
    }
 
    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread t1 = new Thread(){
            @Override
            public void run() {
                while (counter.flag == 0){
                }
                System.out.println("循環(huán)結(jié)束");
            }
        };
        t1.start();
        Thread t2 = new Thread(){
                Scanner scanner = new Scanner(System.in);
                System.out.println("請輸入一個整數(shù)：");
                counter.flag = scanner.nextInt();
        t2.start();

加了volatile之后，對這個內(nèi)存的讀取操作肯定是從內(nèi)存中來讀

不加volatile的時候，讀取操作可能不是從內(nèi)存中讀取，從CPU上讀取舊值，這都是不確定的

volatile 和 synchronized 有著本質(zhì)的區(qū)別.

synchronized 能夠保證原子性, volatile 保證的是內(nèi)存可見性

synchronized 既能保證原子性, 也能保證內(nèi)存可見性.

二、wait 和 notify

由于線程之間是搶占式執(zhí)行的, 因此線程之間執(zhí)行的先后順序難以預(yù)知. 但是實(shí)際開發(fā)中有時候我們希望合理的協(xié)調(diào)多個線程之間的執(zhí)行先后順序

1，wait()方法

wait 做的事情:

使當(dāng)前執(zhí)行代碼的線程進(jìn)行等待. (把線程放到等待隊列中)

釋放當(dāng)前的鎖

滿足一定條件時被喚醒, 重新嘗試獲取這個鎖.

wait 要搭配 synchronized 來使用. 脫離 synchronized 使用 wait 會直接拋出異常.

wait 結(jié)束等待的條件:

其他線程調(diào)用該對象的 notify 方法.

wait 等待時間超時 (wait 方法提供一個帶有 timeout 參數(shù)的版本, 來指定等待時間).

其他線程調(diào)用該等待線程的 interrupted 方法, 導(dǎo)致 wait 拋出 InterruptedException 異常.

public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        synchronized (object){
            System.out.println("等待前");
            object.wait();
            System.out.println("等待后");
        }
    }

就相當(dāng)于一個人去ATM上取錢，發(fā)現(xiàn)ATM中沒錢，然后阻塞等待（不參與后續(xù)鎖的競爭）——wait

等到銀行的工作人員來送錢，你可以取錢了——notify

2，notify()方法

notify 方法是喚醒等待的線程.

        方法notify()也要在同步方法或同步塊中調(diào)用，該方法是用來通知那些可能等待該對象的對象鎖的其它線程，對其發(fā)出通知notify，并使它們重新獲取該對象的對象鎖。

        如果有多個線程等待，則有線程調(diào)度器隨機(jī)挑選出一個呈 wait 狀態(tài)的線程。(并沒有 "先來后到")

        在notify()方法后，當(dāng)前線程不會馬上釋放該對象鎖，要等到執(zhí)行notify()方法的線程將程序執(zhí)行完，也就是退出同步代碼塊之后才會釋放對象鎖。

 public static void main(String[] args) {
        Object locker = new Object();
 
        Thread t1 = new Thread(){
            @Override
            public void run() {
                synchronized (locker){
                    while (true){
                        System.out.println("wait開始");
                        try {
                            locker.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("wait結(jié)束");
                    }
                }
            }
        };
        t1.start();
        Thread t2 = new Thread(){
                Scanner scanner = new Scanner(System.in);
                System.out.println("輸入一個整數(shù)，繼續(xù)執(zhí)行");
                int num = scanner.nextInt();
                    System.out.println("notify開始");
                    locker.notify();
                    System.out.println("notify結(jié)束");
        t2.start();
    }