什麼是記憶體可見性

先介紹幾個概念：

共享變數：

如果一個變數在多個執行緒的工作記憶體中都存在副本，那麼這個變數就是這幾個執行緒的共享變數

可見性：

一個執行緒對共享變數值的修改，能夠及時地被其他執行緒看到

JMM（ JAVA記憶體模型）

JAVA記憶體模型（Java Memory Model） 描述了Java程式中各種變數（共享變數）的訪問規則，以及在JVM中將變數儲存到記憶體中和從記憶體中讀取出變數這樣的底層細節

這裡我們只需要知道：

1. 所有變數都儲存在主記憶體中
2. 每個執行緒都有自己獨立的工作記憶體，裡面儲存該執行緒使用到的變數副本（主記憶體中該變數的一份拷貝）

它有兩條規定：

1. 執行緒對共享變數的所有操作必須在自己的工作記憶體中進行，不可直接從主記憶體中讀取
2. 不同執行緒間無法直接訪問其他執行緒工作區間中的變數，需要通過主記憶體來完成

因此要想實現執行緒1對共享變數的修改被執行緒2及時看到，要經過兩個步驟：

1. 把工作記憶體1中更新過的共享變數重新整理到主記憶體

2.把主記憶體中更新過的共享變數重新整理到工作記憶體2

Synchronized實現可見性

先了解下重排序和as-if-serial語句的概念

重排序

程式碼書寫的順序和實際執行的順序不同

程式碼順序

    int number = 1;
    int
 
 result = 0;

執行順序

    int result = 0;
    int number = 1;

原因是編譯器或者處理器為了提高程式效能做的優化

1. 編譯器優化的重排序 （編譯器優化）
2. 指令級並行重排序（處理器優化）
3. 記憶體系統的重排序（處理器優化）

as-if-serial

無論如何重排序，程式執行的結果應該和程式碼執行的結果一致（JAVA編譯器、執行時和處理器都會保證JAVA在單執行緒下遵循as-if-serial）

    int num1 = 1;
    int num2 = 2;
    int sum = num1 + num2;

單執行緒：第1，2行順序可以重排 但是第3行不行

重排序不會給單執行緒帶來記憶體可見性問題

多執行緒中程式交錯執行時可能會造成記憶體可見性問題

Synchronized可以實現：

• 原子性 （同步）
• 可見性

可見性

JMM關於Synchronized的兩條規定：

1. 執行緒解鎖前，必須把共享變數的最新值重新整理到主記憶體中
2. 執行緒加鎖時，將清空工作記憶體中的共享變數的值，從而使用共享變數時都必須從主記憶體中重新讀取最新的值

因此執行緒解鎖前對共享變數的修改在下次加鎖時對其他執行緒是可見的

執行緒執行互斥程式碼的過程：

1. 獲得互斥鎖
2. 清空工作記憶體
3. 從主記憶體拷貝變數的最新副本到工作記憶體
4. 執行程式碼
5. 將更改後的共享變數的值重新整理到主記憶體
6. 釋放互斥鎖

程式碼示例：

package thread.sychronized;

/**
 * SyncDemo
 * Created by heqianqian on 2017/4/15.
 */
public class SyncDemo {

    private boolean ready = false;
    private int value = 2;
    private int result = 0;

    private synchronized void read() {
        if(ready){
            result = value*3;
        }
        System.out.println("result的值為：" + result);
    }

    private synchronized void write() {
        ready = true;
        value = 10;
    }

    private class MyThread extends Thread{

        private boolean flag;

        public MyThread(boolean flag) {
            this.flag = flag;
        }

        @Override
        public void run() {
            if (flag){
                write();
            }else{
                read();
            }
        }
    }

    public static void main(String[] args) {
        SyncDemo syncDemo = new SyncDemo();
        //寫操作
        syncDemo.new MyThread(true).start();
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //讀操作
        syncDemo.new MyThread(false).start();
    }

}

Volatile實現可見性

通過加入記憶體屏障和禁止重排序優化來實現

• 對volatile變數進行寫操作時 會在寫操作後加入一條store屏障指令
• 對volatile變數進行寫操作時 會在讀操作前加入一條load屏障指令

通俗的來說：

volatile變數在每次被執行緒訪問時，都強迫從主記憶體中讀取該變數的值，而當該變數發生改變時，又會強迫把最近的值重新整理到主記憶體中

volatile不能保證符合操作的原子性

保證操作的原子性

1. 使用synchronized
2. 用ReentranLock實現

要在多執行緒中安全的使用volatile變數 必須同時滿足

1. 對變數的寫入操作不依賴當前值
2. 變數沒有包含在具有其他變數的不變式中