關(guān)于volatile的問題

public class TestThread {
  private static int 普通變量 = 0;
  private volatile static int volatile變量 = 0;

  public static void main(String[] args) {
    new Thread(){
      public void run(){
        System.out.println("開始循環(huán)");
        while(普通變量==0&&volatile變量 ==0){
          //System.out.println("12312321312312321");
        }
        System.out.println("結(jié)束循環(huán)");
        System.exit(0);
      }
    }.start();

    new Thread(){
      public void run(){
          try {
            Thread.sleep(1500);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        System.out.println("開始賦值");
          普通變量 = 1;
      }
    }.start();
  }
}

程序輸出：

開始循環(huán)
開始賦值
結(jié)束循環(huán)

正常結(jié)束了

但是如果把volatile變量的volatile修飾符去掉，那么程序?qū)姥h(huán)。

這個(gè)問題我目前能給出的猜想是，jmm獲取volatile變量的同時(shí)也會刷新獲取非volatile變量的值？

希望并發(fā)大神能幫忙回答一下這個(gè)問題

回答

編輯回答

檸檬藍(lán)

你好，以上的問題在并發(fā)下出現(xiàn)了共享變量不可見的問題，synchronized和volatile都是為了保護(hù)多線程的安全，synchronized具有原子性和可見性，而volatile只有可見性，上面出現(xiàn)接受循環(huán)是因?yàn)槌霈F(xiàn)了線程交叉，volatile不能保證原子性，多線程間共享變量的可見性是其安全的保障。如下圖
圖片說明

1、把工作內(nèi)存A中更新過的共享變量刷新到主內(nèi)存中
2、將主內(nèi)存中最新的共享變量的值更新到工作內(nèi)存B中
而在期間不允許其他線程去更新最新的共享變量，但我們的代碼去發(fā)生了，第一個(gè)線程的判斷執(zhí)行過程中，第二線程對共享變量（普通變量）進(jìn)行了賦值修改，當(dāng)我使用synchronized重新運(yùn)行以上方法時(shí)（synchronized互斥加鎖解鎖），如下代碼

private static int num = 0;
    private static int volatileNum = 0;

    public static void main(String[] args) {
        new Thread(){
            public synchronized void run(){
                System.out.println("開始循環(huán)");
                while(num==0&&volatileNum ==0){
                    //System.err.println("--");
                }
                System.out.println("結(jié)束循環(huán)");
                System.exit(0);
            }
        }.start();

        new Thread(){
            public synchronized void run(){
                try {
                    Thread.sleep(1500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("開始賦值");
                num = 1;
            }
        }.start();
    }

其運(yùn)行結(jié)果就依然是無限循環(huán)，因?yàn)閟ynchronized保證了單線程中的num與volatileNum其獲取時(shí)是主內(nèi)存的最新值，并在運(yùn)行沒有結(jié)束時(shí)不會推送更新到主存儲中，線程二更新后對于第一次獲取到值的判斷線程而言還沒有獲取到num的最新值，不過我發(fā)現(xiàn)一個(gè)有趣的問題，在while中寫入System.out.println(num);后，即使是synchronized下，程序也結(jié)束了循環(huán)，但是如果while中沒有任何執(zhí)行代碼則會一直循環(huán)下去。
這讓我有一個(gè)奇怪的想法：我修改了一下代碼

while (true){
        if(num==0&&volatileNum ==0){
            System.err.println("繼續(xù)循環(huán)");
        }else if(num==1&&volatileNum ==0){
            System.out.println("結(jié)束循環(huán)");
            System.exit(0);
        }
    }

其結(jié)果是在賦值時(shí)，結(jié)束了循環(huán)，即賦值線程更新num變量后，推送到主內(nèi)存中，而判斷線程也獲取到了最新的num變量。且這時(shí)取出synchronized對其也沒有過多影響。將volatileNum重新加volatile后的結(jié)果也是一樣的。

多線程真的很有趣，我發(fā)現(xiàn)我還要去在了解一下，如果你有新的看法也可以告訴我。我不認(rèn)為我回答的就是正確的。
你可以看看我最近寫的兩個(gè)文章，我想聽聽你的意見。
【Java貓說】Java多線程之內(nèi)存可見性（上篇）
【Java貓說】Java多線程之內(nèi)存可見性（下篇）

2017年6月17日 06:36

編輯回答

殘淚

給代碼增加一些輸出信息如下：

public class Main  {
    private static int a = 0;

    private volatile static int b = 0;

    public static void main(String[] args) {
        Test test = new Test();
        new Thread(){
            public void run(){
                System.out.println("開始循環(huán)");
                System.out.println("a:"+a);
                while(a==0&&b==0){
                    System.out.println("a:"+a);
                    //System.out.println("12312321312312321");
                }
                System.out.println("a:"+a);
                System.out.println("結(jié)束循環(huán)");
                System.exit(0);
            }
        }.start();

        new Thread(){
            public void run(){
                try {
                    Thread.sleep(1500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("開始賦值");
                a=1;
            }
        }.start();
    }
}

運(yùn)行代碼輸出

開始循環(huán)
a:0
a:0
a:0
 .
 .
 .
a:0
a:0
開始賦值
a:1
結(jié)束循環(huán)

之后交換a,b位置如下：while(b==0&&a==0){
驚訝的發(fā)現(xiàn)輸出有一些不同：

開始循環(huán)
a:0
a:0
a:0
 .
 .
 .
a:0
a:0
開始賦值
a:0
a:1
結(jié)束循環(huán)

去網(wǎng)上搜了一下發(fā)現(xiàn)這么一段話：

When thread A writes to a volatile variable and subsequently thread B reads the same variable, the values of all variables that were visible to A prior to writing to the volatile variable, become visible to B after reading the volatile variable.

大致理解了一下：thread A對volatile 變量進(jìn)行寫入,隨后thread B讀取此變量的值,在A寫入之前,所有值對A是可見的(即A直接訪問的是(進(jìn)程的)內(nèi)存,不是自己線程的內(nèi)存區(qū)域),在B讀入之后,對B是可見的。因此看這種情況應(yīng)該是因?yàn)橄茸x了b，所以之后的a會對更新變量可見。而先讀a，則這次循環(huán)沒能成功，但是等到讀了b，下一次循環(huán)就能成功，這就是為什么兩次結(jié)果會多循環(huán)一次的原因。

最后，重申一下volitale使用原則：