java中volatile關鍵字的詳解

在java線程併發處理中，有一個關鍵字volatile的使用目前存在很大的混淆，覺得使用這個關鍵字，在進行多線程併發處理的時候就能夠萬事大吉。

Java語言是支持多線程的，爲了解決線程併發的問題，在語言內部引入了 同步塊 和 volatile 關鍵字機制。

synchronized 

同步塊你們都比較熟悉，經過 synchronized 關鍵字來實現，全部加上synchronized 修飾的塊語句和方法，在多線程訪問的時候，同一時刻只能有一個線程可以用

synchronized 修飾的方法 或者 代碼塊。

volatile

用volatile修飾的變量，線程在每次使用變量的時候，都會讀取變量修改後的最的值。volatile很容易被誤用，用來進行原子性操做。

下面看一個例子，咱們實現一個計數器，每次線程啓動的時候，會調用計數器inc方法，對計數器進行加一

public class Counter {
 
    public static int count = 0;
 
    public static void inc() {
 
        //這裏延遲1毫秒，使得結果明顯
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
        }
 
        count++;
    }
 
    public static void main(String[] args) {
 
        //同時啓動1000個線程，去進行i++計算，看看實際結果
 
        for (int i = 0; i < 1000; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Counter.inc();
                }
            }).start();
        }
 
        //這裏每次運行的值都有可能不一樣,可能爲1000
        System.out.println("運行結果:Counter.count=" + Counter.count);
    }
}

運行結果:Counter.count=966

實際運算結果每次可能都不同，本機的結果爲：運行結果:Counter.count=995，能夠看出，在多線程的環境下，Counter.count並無指望結果是1000

不少人覺得，這個是多線程併發問題，只須要在變量count以前加上volatile就能夠避免這個問題，那咱們在修改代碼看看，看看結果是否是符合咱們的指望

public class Counter {
 
    public volatile static int count = 0;
 
    public static void inc() {
 
        //這裏延遲1毫秒，使得結果明顯
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
        }
 
        count++;
    }
 
    public static void main(String[] args) {
 
        //同時啓動1000個線程，去進行i++計算，看看實際結果
 
        for (int i = 0; i < 1000; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Counter.inc();
                }
            }).start();
        }
 
        //這裏每次運行的值都有可能不一樣,可能爲1000
        System.out.println("運行結果:Counter.count=" + Counter.count);
    }
}

運行結果:Counter.count=978

運行結果仍是沒有咱們指望的1000，下面咱們分析一下緣由

在 java 垃圾回收整理一文中，描述了jvm運行時刻內存的分配。其中有一個內存區域是jvm虛擬機棧，每個線程運行時都有一個線程棧，

線程棧保存了線程運行時候變量值信息。當線程訪問某一個對象的值的時候，首先經過對象的引用找到對應在堆內存的變量的值，而後把堆內存

變量的具體值load到線程本地內存中，創建一個變量副本，以後線程就再也不和對象在堆內存變量值有任何關係，而是直接修改副本變量的值，

在修改完以後的某一個時刻（線程退出以前），自動把線程變量副本的值回寫到對象在堆中變量。這樣在堆中的對象的值就產生變化了。下面一幅圖

描述這寫交互

read and load 從主存複製變量到當前工做內存
use and assign  執行代碼，改變共享變量值 
store and write 用工做內存數據刷新主存相關內容

其中use and assign 能夠屢次出現

可是這一些操做並非原子性，也就是 在read load以後，若是主內存count變量發生修改以後，線程工做內存中的值因爲已經加載，不會產生對應的變化，因此計算出來的結果會和預期不同

對於volatile修飾的變量，jvm虛擬機只是保證從主內存加載到線程工做內存的值是最新的

例如假如線程1，線程2 在進行read,load 操做中，發現主內存中count的值都是5，那麼都會加載這個最新的值

在線程1堆count進行修改以後，會write到主內存中，主內存中的count變量就會變爲6

線程2因爲已經進行read,load操做，在進行運算以後，也會更新主內存count的變量值爲6

致使兩個線程即便用volatile關鍵字修改以後，仍是會存在併發的狀況。

volatile保證了可見性，即一個線程修改了inc，那麼其餘線程在下次讀取inc的時候會從內存讀取而不是高速緩存。但對於已經讀取inc的線程就無能爲了了，即沒有保證整個讀取、修改、回寫的原子性。

加鎖機制既能夠確保可見性又能夠確保原子性，而volatile變量只能確保可見性。

經驗證volitile是不能保證原子性，代碼以下：

import java.util.concurrent.CountDownLatch;

public class Test {
    static  class MyObject {
    	
        static  int mycount = 0;
        
        public static  void inc(CountDownLatch latch) {
            MyObject.mycount++;
            latch.countDown();
        }
    }
 
    public static void main(String[] args) throws Exception{
 
        final CountDownLatch latch=new CountDownLatch(100000);
        for (int i = 0; i < 100000; i++) {
            new Thread(new Runnable() {
 
                @Override
                public void run() {
                    MyObject.inc(latch);
                }
            }).start();
        }
         
        latch.await();//等待全部工人完成工做 
        System.out.println("運行結果:Counter.count=" + MyObject.mycount);
    }
}

對volatile聲明的變量單個調用時保持原子性，複合調用時代碼不具有原子性，網上有一段代碼：
 

class VolatileFeaturesExample {
    volatile long vl = 0L;  //使用volatile聲明64位的long型變量
 
    public void set(long l) {
        vl = l;   //單個volatile變量的寫
    }
 
    public void getAndIncrement () {
        vl++;    //複合（多個）volatile變量的讀/寫
    }
 
 
    public long get() {
        return vl;   //單個volatile變量的讀
    }
}

上述代碼在多線程調用時相似下面：

class VolatileFeaturesExample {
    long vl = 0L;               // 64位的long型普通變量
 
    public synchronized void set(long l) {     //對單個的普通 變量的寫用同一個監視器同步
        vl = l;
    }
 
    public void getAndIncrement () { //普通方法調用
        long temp = get();           //調用已同步的讀方法
        temp += 1L;                  //普通寫操做， <b>這裏不具有原子性</b>       
        set(temp);                   //調用已同步的寫方法
    }
    public synchronized long get() {
    //對單個的普通變量的讀用同一個監視器同步
        return vl;
    }
}

上面帖子最後一張線程工做內存的圖就說明了不加volatile關鍵字的狀況，若是加了volatile JMM就會強制線程讀\寫操做直接跟主內存交互，禁用線程工做內存，可是i++這種操做還會有個temp變量做爲中間過渡，以至於致使線程不安全。