synchronized實現可見性

JMM關於synchronized的兩條規定：

　　1）線程解鎖前，必須把共享變量的最新值刷新到主內存中

　　2）線程加鎖時，將清空工作內存中共享變量的值，從而使用共享變量時需要從主內存中重新獲取最新的值

　　　（注意：加鎖與解鎖需要是同一把鎖）

     通過以上兩點，可以看到synchronized能夠實現可見性。同時，由於synchronized具有同步鎖，所以它也具有原子性

　　

 多線程中程序交錯執行時，重排序可能會造成內存可見性問題

 接下來我們看一段代碼：

/**
 * synchronized能夠實現原子性(同步)、可見性
 * 
 * @author xuwenjin
 */
public class SynchronizedDemo {

    //共享變量
    private boolean ready = false;
    private int result = 0;
    private int number = 1;

    /**
     * 寫操作
     */
    public void write() {
        ready = true; //1.1
        number = 2;   //1.2
    }

    /**
     * 讀操作
     */
    public void read() {
        if (ready) {             //2.1
            result = number * 3; //2.2
        }
        System.out.println("result:" + result);
    }

    //內部線程類
    private class WriteReadThread extends Thread {
        
        private  boolean flag = false;
        
        public WriteReadThread(boolean flag){
            this.flag = flag;
        }
        
        @Override
        public void run() {
            if (flag) {
                write();
            }else {
                read();
            }
        }
    }
    
    public static void main(String[] args) {
        SynchronizedDemo demo = new SynchronizedDemo();
        //啟動線程執行寫操作
        demo.new WriteReadThread(true).start();
        //啟動線程執行讀操作
        demo.new WriteReadThread(false).start();
    }

}

 上面的代碼可能出現如下執行順序：

　　1） 1.1 --> 1.2 --> 2.1--> 2.2       result的值為6 (正常情況)

　　2） 1.1 --> 2.1 --> 2.2 --> 1.2       result的值為3 (當寫線程執行完1.1之后，讀線程開始)

　　3） 1.2 --> 2.1 --> 2.2 --> 1.1       result的值為0 (1.1跟1.2重排序)

　　4）...

 當然由於重排序和線程的交叉執行，還可能出現很多種執行順序

 導致共享變量在線程間不可見的原因：

　　a、線程的異步執行

　　b、重排序結合線程交叉執行

　　c、共享變量更新后的值沒有在工作內存與主內存間及時更新

 那么如何解決可見性的問題呢？接下來我們的主角出場：synchronized

 安全的代碼：

    /**
     * 寫操作
     */
    public synchronized void write() {
        ready = true; //1.1
        number = 2;   //1.2
    }

    /**
     * 讀操作
     */
    public synchronized void read() {
        if (ready) {             //2.1
            result = number * 3; //2.2
        }
        System.out.println("result:" + result);
    }

由於synchronized的原子性、可見性，可以完美解決以上說的三點問題。不過讀線程和寫線程的執行順序是不定的，所以result的結果仍然會出現6或0。

如何保證線程順序執行，大家可參考：https://blog.csdn.net/wenxingchen/article/details/78026767