java之用volatile和不用volatile的區別

轉載：http://blog.csdn.net/feier7501/article/details/20001083

在當前的Java內存模型下，線程可以把變量保存在本地內存（比如機器的寄存器）中，而不是直接在主存中進行讀寫。這就可能造成一個線程在主存中修改了一個變量的值，而另外一個線程還繼續使用它在寄存器中的變量值的拷貝，造成數據的不一致。 

要解決這個問題，只需要像在本程序中的這樣，把該變量聲明為volatile（不穩定的）即可，這就指示JVM，這個變量是不穩定的，每次使用它都到主存中進行讀取。一般說來，多任務環境下各任務間共享的標志都應該加volatile修飾。 

Volatile修飾的成員變量在每次被線程訪問時，都強迫從共享內存中重讀該成員變量的值。而且，當成員變量發生變化時，強迫線程將變化值回寫到共享內存。這樣在任何時刻，兩個不同的線程總是看到某個成員變量的同一個值。 

 

用volatile和不用volatile的區別，運行一下，就知道了。

不用volatile：

 

package com.keyword;

public class TestWithoutVolatile {
    private static boolean bChanged;

    public static void main(String[] args) throws InterruptedException {
        new Thread() {

            @Override
            public void run() {
                for (;;) {
                    if (bChanged == !bChanged) {
                        System.out.println("!=");
                        System.exit(0);
                    }
                }
            }
        }.start();
        Thread.sleep(1);
        new Thread() {

            @Override
            public void run() {
                for (;;) {
                    bChanged = !bChanged;
                }
            }
        }.start();
    }

}

運行后，程序進入死循環了，一直在運行。

 

 

用volatile：

 

package com.keyword;

public class TestWithVolatile {
    private static volatile boolean bChanged;

    public static void main(String[] args) throws InterruptedException {
        new Thread() {

            @Override
            public void run() {
                for (;;) {
                    if (bChanged == !bChanged) {
                        System.out.println("!=");
                        System.exit(0);
                    }
                }
            }
        }.start();
        Thread.sleep(1);
        new Thread() {

            @Override
            public void run() {
                for (;;) {
                    bChanged = !bChanged;
                }
            }
        }.start();
    }

}

程序輸出!=，然后馬上退出。

 

但是，很多情況下，用不用volatile，感覺不出什么區別，什么時候要用volatile呢？看看JDK里使用volatile的類。

比如java.util.regex.Pattern里的變量：

 

private transient volatile boolean compiled = false;

還有，java.lang.System的變量：

 

 

private static volatile Console cons = null;

一般就是初始化的時候，需要用到volatile。

 

java.util.Scanner里的變量，如：

 

private static volatile Pattern boolPattern;
private static volatile Pattern separatorPattern;
private static volatile Pattern linePattern;

初始化boolPattern的代碼：

 

 

private static Pattern boolPattern() {
        Pattern bp = boolPattern;
        if (bp == null)
            boolPattern = bp = Pattern.compile(BOOLEAN_PATTERN,
                                          Pattern.CASE_INSENSITIVE);
        return bp;
}

 

 

上面的情況，可以使用synchronized來對boolPattern加鎖，但是synchronized開銷比volatile大，volatile能夠勝任上面的工作。

 

volatile不保證原子操作，所以，很容易讀到臟數據。

 

使用建議：在兩個或者更多的線程訪問的成員變量上使用volatile。當要訪問的變量已在synchronized代碼塊中，或者為常量時，不必使用。