1. 程式人生 > >Java併發程式設計(三)volatile域

Java併發程式設計(三)volatile域

前言

有時僅僅為了讀寫一個或者兩個例項域就使用同步的話,顯得開銷過大,volatile關鍵字為例項域的同步訪問提供了免鎖的機制。如果宣告一個域為volatile,那麼編譯器和虛擬機器就知道該域是可能被另一個執行緒併發更新的。再講到volatile關鍵字之前我們需要了解一下記憶體模型的相關概念以及併發程式設計中的三個特性:原子性,可見性和有序性。

1. java記憶體模型與原子性,可見性和有序性

Java記憶體模型規定所有的變數都是存在主存當中,每個執行緒都有自己的工作記憶體。執行緒對變數的所有操作都必須在工作記憶體中進行,而不能直接對主存進行操作。並且每個執行緒不能訪問其他執行緒的工作記憶體。
在java中,執行下面這個語句:

int i=3;

執行執行緒必須先在自己的工作執行緒中對變數i所在的快取行進行賦值操作,然後再寫入主存當中。而不是直接將數值3寫入主存當中。
那麼Java語言 本身對 原子性、可見性以及有序性提供了哪些保證呢?

原子性

對基本資料型別的變數的讀取和賦值操作是原子性操作,即這些操作是不可被中斷的,要麼執行,要麼不執行。
來看一下下面的程式碼:

x = 10;        //語句1
y = x;         //語句2
x++;           //語句3
x = x + 1;     //語句4

只有語句1是原子性操作,其他三個語句都不是原子性操作。
語句2實際上包含2個操作,它先要去讀取x的值,再將x的值寫入工作記憶體,雖然讀取x的值以及 將x的值寫入工作記憶體 這2個操作都是原子性操作,但是合起來就不是原子性操作了。
同樣的,x++和 x = x+1包括3個操作:讀取x的值,進行加1操作,寫入新的值。
也就是說,只有簡單的讀取、賦值(而且必須是將數字賦值給某個變數,變數之間的相互賦值不是原子操作)才是原子操作。
java.util.concurrent.atomic包中有很多類使用了很高效的機器級指令(而不是使用鎖)來保證其他操作的原子性。例如AtomicInteger類提供了方法incrementAndGet和decrementAndGet,它們分別以原子方式將一個整數自增和自減。可以安全地使用AtomicInteger類作為共享計數器而無需同步。
另外這個包還包含AtomicBoolean,AtomicLong和AtomicReference這些原子類僅供開發併發工具的系統程式設計師使用,應用程式設計師不應該使用這些類。

可見性

可見性,是指執行緒之間的可見性,一個執行緒修改的狀態對另一個執行緒是可見的。也就是一個執行緒修改的結果。另一個執行緒馬上就能看到。
當一個共享變數被volatile修飾時,它會保證修改的值會立即被更新到主存,所以對其他執行緒是可見的,當有其他執行緒需要讀取時,它會去記憶體中讀取新值。
而普通的共享變數不能保證可見性,因為普通共享變數被修改之後,什麼時候被寫入主存是不確定的,當其他執行緒去讀取時,此時記憶體中可能還是原來的舊值,因此無法保證可見性。

有序性

在Java記憶體模型中,允許編譯器和處理器對指令進行重排序,但是重排序過程不會影響到單執行緒程式的執行,卻會影響到多執行緒併發執行的正確性。
可以通過volatile關鍵字來保證一定的“有序性”。另外可以通過synchronized和Lock來保證有序性,很顯然,synchronized和Lock保證每個時刻是有一個執行緒執行同步程式碼,相當於是讓執行緒順序執行同步程式碼,自然就保證了有序性。

2. volatile關鍵字

一旦一個共享變數(類的成員變數、類的靜態成員變數)被volatile修飾之後,那麼就具備了兩層語義:

  • 保證了不同執行緒對這個變數進行操作時的可見性,即一個執行緒修改了某個變數的值,這新值對其他執行緒來說是立即可見的。
  • 禁止進行指令重排序。

先看一段程式碼,假如執行緒1先執行,執行緒2後執行:
  

//執行緒1
boolean stop = false;
while(!stop){
    doSomething();
}

//執行緒2
stop = true;

很多人在中斷執行緒時可能都會採用這種標記辦法。但是事實上,這段程式碼會完全執行正確麼?即一定會將執行緒中斷麼?不一定,也許在大多數時候,這個程式碼能夠把執行緒中斷,但是也有可能會導致無法中斷執行緒(雖然這個可能性很小,但是隻要一旦發生這種情況就會造成死迴圈了)。
為何有可能導致無法中斷執行緒?每個執行緒在執行過程中都有自己的工作記憶體,那麼執行緒1在執行的時候,會將stop變數的值拷貝一份放在自己的工作記憶體當中。那麼當執行緒2更改了stop變數的值之後,但是還沒來得及寫入主存當中,執行緒2轉去做其他事情了,那麼執行緒1由於不知道執行緒2對stop變數的更改,因此還會一直迴圈下去。
但是用volatile修飾之後就變得不一樣了:

  • 使用volatile關鍵字會強制將修改的值立即寫入主存;
  • 使用volatile關鍵字的話,當執行緒2進行修改時,會導致執行緒1的工作記憶體中快取變數stop的快取行無效;
  • 由於執行緒1的工作記憶體中快取變數stop的快取行無效,所以執行緒1再次讀取變數stop的值時會去主存讀取。

volatile保證原子性嗎?

我們知道volatile關鍵字保證了操作的可見性,但是volatile能保證對變數的操作是原子性嗎?

public class Test {
    public volatile int inc = 0;  
    public void increase() {
        inc++;
    }

    public static void main(String[] args) {
        final Test test = new Test();
        for(int i=0;i<10;i++){
            new Thread(){
                public void run() {
                    for(int j=0;j<1000;j++)
                        test.increase();
                };
            }.start();
        }
         //保證前面的執行緒都執行完
        while(Thread.activeCount()>1)  
            Thread.yield();
        System.out.println(test.inc);
    }
}

這段程式碼每次執行結果都不一致,都是一個小於10000的數字,在前面已經提到過,自增操作是不具備原子性的,它包括讀取變數的原始值、進行加1操作、寫入工作記憶體。那麼就是說自增操作的三個子操作可能會分割開執行。
假如某個時刻變數inc的值為10,執行緒1對變數進行自增操作,執行緒1先讀取了變數inc的原始值,然後執行緒1被阻塞了;然後執行緒2對變數進行自增操作,執行緒2也去讀取變數inc的原始值,由於執行緒1只是對變數inc進行讀取操作,而沒有對變數進行修改操作,所以不會導致執行緒2的工作記憶體中快取變數inc的快取行無效,所以執行緒2會直接去主存讀取inc的值,發現inc的值時10,然後進行加1操作,並把11寫入工作記憶體,最後寫入主存。然後執行緒1接著進行加1操作,由於已經讀取了inc的值,注意此時線上程1的工作記憶體中inc的值仍然為10,所以執行緒1對inc進行加1操作後inc的值為11,然後將11寫入工作記憶體,最後寫入主存。那麼兩個執行緒分別進行了一次自增操作後,inc只增加了1。
自增操作不是原子性操作,而且volatile也無法保證對變數的任何操作都是原子性的。

volatile能保證有序性嗎?

在前面提到volatile關鍵字能禁止指令重排序,所以volatile能在一定程度上保證有序性。
volatile關鍵字禁止指令重排序有兩層意思:

  • 當程式執行到volatile變數的讀操作或者寫操作時,在其前面的操作的更改肯定全部已經進行,且結果已經對後面的操作可見;在其後面的操作肯定還沒有進行;
  • 在進行指令優化時,不能將在對volatile變數訪問的語句放在其後面執行,也不能把volatile變數後面的語句放到其前面執行。

3. 正確使用volatile關鍵字

synchronized關鍵字是防止多個執行緒同時執行一段程式碼,那麼就會很影響程式執行效率,而volatile關鍵字在某些情況下效能要優於synchronized,但是要注意volatile關鍵字是無法替代synchronized關鍵字的,因為volatile關鍵字無法保證操作的原子性。通常來說,使用volatile必須具備以下2個條件:

  • 對變數的寫操作不依賴於當前值
  • 該變數沒有包含在具有其他變數的不變式中

第一個條件就是不能是自增自減等操作,上文已經提到volatile不保證原子性。
第二個條件我們來舉個例子它包含了一個不變式 :下界總是小於或等於上界

public class NumberRange {
    private volatile int lower, upper;
    public int getLower() { return lower; }
    public int getUpper() { return upper; }
    public void setLower(int value) { 
        if (value > upper) 
            throw new IllegalArgumentException(...);
        lower = value;
    }
    public void setUpper(int value) { 
        if (value < lower) 
            throw new IllegalArgumentException(...);
        upper = value;
    }
}

這種方式限制了範圍的狀態變數,因此將 lower 和 upper 欄位定義為 volatile 型別不能夠充分實現類的執行緒安全,從而仍然需要使用同步。否則,如果湊巧兩個執行緒在同一時間使用不一致的值執行 setLower 和 setUpper 的話,則會使範圍處於不一致的狀態。例如,如果初始狀態是 (0, 5),同一時間內,執行緒 A 呼叫 setLower(4) 並且執行緒 B 呼叫 setUpper(3),顯然這兩個操作交叉存入的值是不符合條件的,那麼兩個執行緒都會通過用於保護不變式的檢查,使得最後的範圍值是 (4, 3),這顯然是不對的。
其實就是要保證操作的原子性就可以使用volatile,使用volatile主要有兩個場景:

狀態標誌

volatile boolean shutdownRequested;
...
public void shutdown()
 { 
 shutdownRequested = true;
  }
public void doWork() { 
    while (!shutdownRequested) { 
        // do stuff
    }
}

很可能會從迴圈外部呼叫 shutdown() 方法 —— 即在另一個執行緒中 —— 因此,需要執行某種同步來確保正確實現 shutdownRequested 變數的可見性。然而,使用 synchronized 塊編寫迴圈要比使用volatile 狀態標誌編寫麻煩很多。由於 volatile 簡化了編碼,並且狀態標誌並不依賴於程式內任何其他狀態,因此此處非常適合使用 volatile。

雙重檢查模式 (DCL)

public class Singleton {  
    private volatile static Singleton instance = null;  
    public static Singleton getInstance() {  
        if (instance == null) {  
            synchronized(this) {  
                if (instance == null) {  
                    instance = new Singleton();  
                }  
            }  
        }  
        return instance;  
    }  
}  

在這裡使用volatile會或多或少的影響效能,但考慮到程式的正確性,犧牲這點效能還是值得的。
DCL優點是資源利用率高,第一次執行getInstance時單例物件才被例項化,效率高。缺點是第一次載入時反應稍慢一些,在高併發環境下也有一定的缺陷,雖然發生的概率很小。
DCL雖然在一定程度解決了資源的消耗和多餘的同步,執行緒安全等問題,但是他還是在某些情況會出現失效的問題,也就是DCL失效,在《java併發程式設計實踐》一書建議用以下的程式碼(靜態內部類單例模式)來替代DCL:

public class Singleton { 
    private Singleton(){
    }
      public static Singleton getInstance(){  
        return SingletonHolder.sInstance;  
    }  
    private static class SingletonHolder {  
        private static final Singleton sInstance = new Singleton();  
    }  
} 

4. 總結

與鎖相比,Volatile 變數是一種非常簡單但同時又非常脆弱的同步機制,它在某些情況下將提供優於鎖的效能和伸縮性。如果嚴格遵循 volatile 的使用條件即變數真正獨立於其他變數和自己以前的值 ,在某些情況下可以使用 volatile 代替 synchronized 來簡化程式碼。然而,使用 volatile 的程式碼往往比使用鎖的程式碼更加容易出錯。本文介紹了可以使用 volatile 代替 synchronized 的最常見的兩種用例,其他的情況我們最好還是去使用synchronized 。

相關推薦

no