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

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

當(dāng)一個(gè)變量定義成volatile之后, 保證了此變量對(duì)所有線程的可見(jiàn)性,也就是說(shuō)當(dāng)一條線程修改了這個(gè)變量的值,新的值對(duì)于其它線程來(lái)說(shuō)是可以立即得知的.此時(shí),該變量的讀寫(xiě)操作直接在主內(nèi)存中完成.

Volatile 變量具有 synchronized 的可見(jiàn)性特性，但是不具備原子特性。

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

雖然增量操作（x++）看上去類(lèi)似一個(gè)單獨(dú)操作，實(shí)際上它是一個(gè)由讀?。薷模瓕?xiě)入操作序列組成的組合操作，必須以原子方式執(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)境下, 各個(gè)線程的讀/寫(xiě)操作可能有重疊現(xiàn)象, 在這個(gè)時(shí)候, volatile并不能保證數(shù)據(jù)同步.

下面將給出一個(gè)實(shí)例:

實(shí)例 ==> 500個(gè)線程一起運(yùn)行,每個(gè)線程對(duì)1到100求和1000次操作,然后將一個(gè)volatile共享變量值加1. 當(dāng)500個(gè)線程都完成操作之后, 期望的值是500,因?yàn)槊總€(gè)線程執(zhí)行完畢之后都會(huì)對(duì)這個(gè)volatile變量加1.

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

public class NonSafeThread implements Runnable { 
 
    /** 共享資源, 每個(gè)線程執(zhí)行完之后加 1 */ 
    private volatile int volatileCount = 0; 
 
    public void run() { 
 
        /* 
         * 每個(gè)線程調(diào)用sum100()方法，1000次 
         */ 
 
        for (int i = 1; i <= 1000; i++) { 
            sum100(); 
        } 
 
        /* 
         * 計(jì)算完畢之后， volatileCount 加 1 
         */ 
 
        increase(); 
    } 
     
    private void increase() 
    { 
        volatileCount++; 
    } 
 
    /** 
     * 對(duì) 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)建一個(gè)是線程組 */ 
        ThreadGroup threadGroup = Thread.currentThread().getThreadGroup(); 
 
        for (;;) { 
            loopCount++; 
 
            /* 
             * 啟動(dòng)500個(gè)線程，初始化的線程會(huì)添加到當(dāng)前線程組中 
             */ 
            NonSafeThread nonSafeThread = new NonSafeThread(); 
            startThreads(nonSafeThread); 
 
            /* 
             * 如果線程組中除了主線程之外，還有其它線程，則休眠5毫秒，然后再判斷線程組中 剩余的線程數(shù)，直到只剩下主線程一個(gè)為止。 
             */ 
            while (!isOnlyMainThreadLeft(threadGroup)) { 
                sleep(5); 
            } 
 
            /* 
             * 500個(gè)線程運(yùn)行完畢，那么此時(shí)的volatile變量volatileCount的值應(yīng)該500， 因?yàn)槊總€(gè)線程將其值加1。 
             *  
             * 驗(yàn)證是否出現(xiàn)線程不安全的情況。 
             */ 
            validate(loopCount, nonSafeThread.getVolatileCount(), 500); 
        } 
    } 
 
    /** 
     * 啟動(dòng)500個(gè)線程 
     */ 
    private static void startThreads(NonSafeThread nonSafeThread) { 
 
        for (int i = 0; i < 500; i++) { 
            new Thread(nonSafeThread).start(); 
        } 
    } 
 
    /** 
     * 驗(yàn)證是否出現(xiàn)線程不安全的情況。 如果是，則打印出線程不安全的信息。 
     */ 
    private static void validate(int loopCount, int actualValue, 
            int expectedValue) { 
        if (!isVolatileCountExpected(actualValue, expectedValue)) { 
            printNonSafeMessage(loopCount, actualValue, expectedValue); 
            /* 
             * 正常退出程序。 
             */ 
            System.exit(0); 
        } 
    } 
 
    /** 
     * 在控制臺(tái)打印出現(xiàn)線程不安全時(shí)的信息。 
     */ 
    private static void printNonSafeMessage(int loopCount, int actualValue, 
            int expectedValue) { 
        System.out.println(String.format( 
                "第%d次循環(huán)，出現(xiàn)線程不安全的情況，volatile的值不正確,期望值是%d, 但是500個(gè)線程運(yùn)行的情況下是%d", 
                loopCount, expectedValue, actualValue)); 
    } 
 
    /** 
     * 判斷實(shí)際中的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(); 
        } 
    } 
 
    /** 
     * 判斷一個(gè)線程組是否只剩下主線程了。 
     *  
     * 如果是則返回true，如果不是則放回false. 
     */ 
    private static boolean isOnlyMainThreadLeft(ThreadGroup tg) { 
        return tg.activeCount() == 1; 
    } 
 
} 

某次運(yùn)行,輸出的結(jié)果如下：

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

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

如:

1. 使用Lock,修改NonSafeThread類(lèi)的run方法的內(nèi)容：

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

2. 使用synchronized

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

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

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