在本篇博文中,將給出一個實例去驗證volatile修飾的變量并不能保證其數(shù)據(jù)同步。

Java內存模型規(guī)定了所有變量都存儲在主內存中，每條線程都有自己的工作內存，線程的工作內存保存了被該線程使用到變量的主內存副本拷貝，線程 對變量的所有操作(讀取,賦值等)都必須在工作內存中進行，而不能直接讀寫主內存中的變量。不同線程也不能直接訪問對方工作內存中的變量，線程間變量值的 傳遞均需要通過主內存來完成，線程，主內存，工作內存三者的交互關系如圖所示。

當一個變量定義成volatile之后, 保證了此變量對所有線程的可見性,也就是說當一條線程修改了這個變量的值,新的值對于其它線程來說是可以立即得知的.此時,該變量的讀寫操作直接在主內存中完成.

Volatile 變量具有 synchronized 的可見性特性，但是不具備原子特性。

Volatile variables share the visibility features of synchronized, but none of the atomicity features.

雖然增量操作（x++）看上去類似一個單獨操作，實際上它是一個由讀?。薷模瓕懭氩僮餍蛄薪M成的組合操作，必須以原子方式執(zhí)行，而 volatile 不能提供必須的原子特性。

While the increment operation (x++) may look like a single operation, it is really a compound read-modify-write sequence of operations that must execute atomically -- and volatile does not provide the necessary atomicity.

在多線程并發(fā)的環(huán)境下, 各個線程的讀/寫操作可能有重疊現(xiàn)象, 在這個時候, volatile并不能保證數(shù)據(jù)同步.

下面將給出一個實例:

實例 ==> 500個線程一起運行,每個線程對1到100求和1000次操作,然后將一個volatile共享變量值加1. 當500個線程都完成操作之后, 期望的值是500,因為每個線程執(zhí)行完畢之后都會對這個volatile變量加1.

一直循環(huán)執(zhí)行這個程序,直到出現(xiàn)volatile變量的值小于500為止,也就是出現(xiàn)數(shù)據(jù)不同步。

public class NonSafeThread implements Runnable { 
 
    /** 共享資源, 每個線程執(zhí)行完之后加 1 */ 
    private volatile int volatileCount = 0; 
 
    public void run() { 
 
        /* 
         * 每個線程調用sum100()方法，1000次 
         */ 
 
        for (int i = 1; i <= 1000; i++) { 
            sum100(); 
        } 
 
        /* 
         * 計算完畢之后， volatileCount 加 1 
         */ 
 
        increase(); 
    } 
     
    private void increase() 
    { 
        volatileCount++; 
    } 
 
    /** 
     * 對 1 到 100 求和 
     */ 
    private int sum100() { 
        int result = 0; 
        for (int i = 1; i <= 100; i++) { 
            result += i; 
        } 
        return result; 
    } 
 
    /** 
     * @return the volatileCount 
     */ 
    public int getVolatileCount() { 
        return volatileCount; 
    } 
 
} 

/** 
 * @author Eric 
 *  
 * @version 1.0 
 */ 
 
public class NonSafeThreadTest { 
 
    public static void main(String[] args) { 
 
        /** 記錄循環(huán)次數(shù) */ 
        int loopCount = 0; 
 
        /** 以main函數(shù)主線程創(chuàng)建一個是線程組 */ 
        ThreadGroup threadGroup = Thread.currentThread().getThreadGroup(); 
 
        for (;;) { 
            loopCount++; 
 
            /* 
             * 啟動500個線程，初始化的線程會添加到當前線程組中 
             */ 
            NonSafeThread nonSafeThread = new NonSafeThread(); 
            startThreads(nonSafeThread); 
 
            /* 
             * 如果線程組中除了主線程之外，還有其它線程，則休眠5毫秒，然后再判斷線程組中 剩余的線程數(shù)，直到只剩下主線程一個為止。 
             */ 
            while (!isOnlyMainThreadLeft(threadGroup)) { 
                sleep(5); 
            } 
 
            /* 
             * 500個線程運行完畢，那么此時的volatile變量volatileCount的值應該500， 因為每個線程將其值加1。 
             *  
             * 驗證是否出現(xiàn)線程不安全的情況。 
             */ 
            validate(loopCount, nonSafeThread.getVolatileCount(), 500); 
        } 
    } 
 
    /** 
     * 啟動500個線程 
     */ 
    private static void startThreads(NonSafeThread nonSafeThread) { 
 
        for (int i = 0; i < 500; i++) { 
            new Thread(nonSafeThread).start(); 
        } 
    } 
 
    /** 
     * 驗證是否出現(xiàn)線程不安全的情況。 如果是，則打印出線程不安全的信息。 
     */ 
    private static void validate(int loopCount, int actualValue, 
            int expectedValue) { 
        if (!isVolatileCountExpected(actualValue, expectedValue)) { 
            printNonSafeMessage(loopCount, actualValue, expectedValue); 
            /* 
             * 正常退出程序。 
             */ 
            System.exit(0); 
        } 
    } 
 
    /** 
     * 在控制臺打印出現(xiàn)線程不安全時的信息。 
     */ 
    private static void printNonSafeMessage(int loopCount, int actualValue, 
            int expectedValue) { 
        System.out.println(String.format( 
                "第%d次循環(huán)，出現(xiàn)線程不安全的情況，volatile的值不正確,期望值是%d, 但是500個線程運行的情況下是%d", 
                loopCount, expectedValue, actualValue)); 
    } 
 
    /** 
     * 判斷實際中的volatile值與期望值是否一致。 
     */ 
    private static boolean isVolatileCountExpected(int actualValue, 
            int expectedValue) { 
        return actualValue == expectedValue; 
    } 
 
    /** 
     * 讓線程休眠millis毫秒 
     */ 
    private static void sleep(long millis) { 
        try { 
            Thread.sleep(millis); 
        } catch (InterruptedException e) { 
            // TODO Auto-generated catch block 
            e.printStackTrace(); 
        } 
    } 
 
    /** 
     * 判斷一個線程組是否只剩下主線程了。 
     *  
     * 如果是則返回true，如果不是則放回false. 
     */ 
    private static boolean isOnlyMainThreadLeft(ThreadGroup tg) { 
        return tg.activeCount() == 1; 
    } 
 
} 

某次運行,輸出的結果如下：

第83次循環(huán)，出現(xiàn)線程不安全的情況，volatile的值不正確,期望值是500, 但是500個線程運行的情況下是499

在這種情況下,可以通過 Lcak和synchronized來保證數(shù)據(jù)的同步。

如:

1. 使用Lock,修改NonSafeThread類的run方法的內容：

public void run() { 
 
        lock.lock(); 
 
        try { 
            /* 
             * 每個線程調用sum100()方法，1000次 
             */ 
 
            for (int i = 1; i <= 1000; i++) { 
                sum100(); 
            } 
 
            /* 
             * 計算完畢之后， volatileCount 加 1 
             */ 
 
            increase(); 
             
        } finally { 
            lock.unlock(); 
        } 
 
    } 

2. 使用synchronized

public void run() { 
 
        synchronized ("") { 
            /* 
             * 每個線程調用sum100()方法，1000次 
             */ 
 
            for (int i = 1; i <= 1000; i++) { 
                sum100(); 
            } 
 
            /* 
             * 計算完畢之后， volatileCount 加 1 
             */ 
 
            increase(); 
        } 
    } 

如果用Lock或者synchronized修改了NonSafeThread類, 如果再想跑這個程序的話,需要控制一下NonSafeThreadTest中for循環(huán)中執(zhí)行的次數(shù),比如1000次 (我運行程序的時候,一般都在100次以內打印出數(shù)據(jù)不安全的結果),以免導致程序在Lock或者synchronized修改后一直執(zhí)行下去.

原文鏈接：http://mouselearnjava.iteye.com/blog/1920154