Java多線程 volatile關(guān)鍵字詳解

更新時間：2019年09月06日 09:47:01 作者：慢慢來

這篇文章主要介紹了Java多線程 volatile關(guān)鍵字詳解,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

volatile

volatile是一種輕量同步機制。請看例子

MyThread25類

public class MyThread25 extends Thread{
  private boolean isRunning = true;

  public boolean isRunning()
  {
    return isRunning;
  }

  public void setRunning(boolean isRunning)
  {
    this.isRunning = isRunning;
  }

  public void run()
  {
    System.out.println("進入run了");
    while (isRunning == true){}
    System.out.println("線程被停止了");
  }
  public static void main(String[] args) throws InterruptedException {

    MyThread25 mt = new MyThread25();
    mt.start();
    Thread.sleep(1000);
    mt.setRunning(false);
    System.out.println("已設置為false");
  }
}

輸出結(jié)果如下

進入run了
已設置為false

為什么程序始終不結(jié)束？說明mt.setRunning(false);沒有起作用。

這里我們說下Java內(nèi)存模型（JMM）

java虛擬機有自己的內(nèi)存模型（Java Memory Model，JMM），JMM可以屏蔽掉各種硬件和操作系統(tǒng)的內(nèi)存訪問差異，以實現(xiàn)讓java程序在各種平臺下都能達到一致的內(nèi)存訪問效果。

JMM定義了線程和主內(nèi)存之間的抽象關(guān)系：共享變量存儲在主內(nèi)存(Main Memory)中，每個線程都有一個私有的本地內(nèi)存（Local Memory），本地內(nèi)存保存了被該線程使用到的主內(nèi)存的副本，線程對變量的所有操作都必須在本地內(nèi)存中進行，而不能直接讀寫主內(nèi)存中的變量。這三者之間的交互關(guān)系如下

出現(xiàn)上述運行結(jié)果的原因是，主內(nèi)存isRunning = true， mt.setRunning(false)設置主內(nèi)存isRunning = false，本地內(nèi)存中isRunning仍然是true，線程用的是本地內(nèi)存，所以進入了死循環(huán)。

在isRunning前加上volatile

private volatile boolean isRunning = true;

輸出結(jié)果如下

進入run了
已設置為false
線程被停止了

volatile不能保證原子類線程安全

先看例子

MyThread26_0類，用volatile修飾num

public class MyThread26_0 extends Thread {
  public static volatile int num = 0;
  //使用CountDownLatch來等待計算線程執(zhí)行完
  static CountDownLatch countDownLatch = new CountDownLatch(30);
  @Override
  public void run() {
    for(int j=0;j<1000;j++){
      num++;//自加操作
    }
    countDownLatch.countDown();
  }
  public static void main(String[] args) throws InterruptedException {
    MyThread26_0[] mt = new MyThread26_0[30];
    //開啟30個線程進行累加操作
    for(int i=0;i<mt.length;i++){
      mt[i] = new MyThread26_0();
    }
    for(int i=0;i<mt.length;i++){
      mt[i].start();
    }
    //等待計算線程執(zhí)行完
    countDownLatch.await();
    System.out.println(num);
  }
}

輸出結(jié)果如下

理論上，應該輸出30000。原子操作表示一段操作是不可分割的，因為num++不是原子操作，這樣會出現(xiàn)線程對過期的num進行自增，此時其他線程已經(jīng)對num進行了自增。

num++分三步：讀取、加一、賦值。

結(jié)論：

volatile只會對單個的的變量讀寫具有原子性，像num++這種復合操作volatile是無法保證其原子性的

解決方法：

用原子類AtomicInteger的incrementAndGet方法自增

public class MyThread26_1 extends Thread {
  //使用原子操作類
  public static AtomicInteger num = new AtomicInteger(0);
  //使用CountDownLatch來等待計算線程執(zhí)行完
  static CountDownLatch countDownLatch = new CountDownLatch(30);

  @Override
  public void run() {
    for(int j=0;j<1000;j++){
      num.incrementAndGet();//原子性的num++,通過循環(huán)CAS方式
    }
    countDownLatch.countDown();
  }

  public static void main(String []args) throws InterruptedException {
    MyThread26_1[] mt = new MyThread26_1[30];
    //開啟30個線程進行累加操作
    for(int i=0;i<mt.length;i++){
      mt[i] = new MyThread26_1();
    }
    for(int i=0;i<mt.length;i++){
      mt[i].start();
    }
    //等待計算線程執(zhí)行完
    countDownLatch.await();
    System.out.println(num);
  }
}

輸出結(jié)果如下

原子類方法組合使用線程不安全

例子如下

ThreadDomain27類

public class ThreadDomain27 {
  public static AtomicInteger aiRef = new AtomicInteger();
  public void addNum()
  {
    System.out.println(Thread.currentThread().getName() + "加了100之后的結(jié)果：" + aiRef.addAndGet(100));
    aiRef.getAndAdd(1);
  }
}

MyThread27類

public class MyThread27 extends Thread{
  private ThreadDomain27 td;

  public MyThread27(ThreadDomain27 td)
  {
    this.td = td;
  }

  public void run()
  {
    td.addNum();
  }

  public static void main(String[] args)
  {
    try
    {
      ThreadDomain27 td = new ThreadDomain27();
      MyThread27[] mt = new MyThread27[5];
      for (int i = 0; i < mt.length; i++)
      {
        mt[i] = new MyThread27(td);
      }
      for (int i = 0; i < mt.length; i++)
      {
        mt[i].start();
      }
      Thread.sleep(1000);
      System.out.println(ThreadDomain27.aiRef.get());
    }
    catch (InterruptedException e)
    {
      e.printStackTrace();
    }
  }
}

輸出結(jié)果如下

Thread-2加了100之后的結(jié)果：100
Thread-3加了100之后的結(jié)果：200
Thread-0加了100之后的結(jié)果：302
Thread-1加了100之后的結(jié)果：403
Thread-4加了100之后的結(jié)果：504
505

理想的輸出結(jié)果是100，201，302...，因為addAndGet方法和getAndAdd方法構(gòu)成的addNum不是原子操作。
解決該問題只需要在addNum加上synchronized關(guān)鍵字。

輸出結(jié)果如下

Thread-1加了100之后的結(jié)果：100
Thread-0加了100之后的結(jié)果：201
Thread-2加了100之后的結(jié)果：302
Thread-3加了100之后的結(jié)果：403
Thread-4加了100之后的結(jié)果：504
505

結(jié)論：

volatile解決的是變量在多個線程之間的可見性，但是無法保證原子性。
synchronized不僅保障了原子性外，也保障了可見性。

volatile和synchronized比較

先看實例，使用volatile是什么效果

CountDownLatch保證10個線程都能執(zhí)行完成，當然你也可以在System.out.println(test.inc);之前使用Thread.sleep(xxx)

public class MyThread28 {
  //使用CountDownLatch來等待計算線程執(zhí)行完
  static CountDownLatch countDownLatch = new CountDownLatch(10);
  public volatile int inc = 0;
  public void increase() {
    inc++;
  }
  public static synchronized void main(String[] args) throws InterruptedException {
    final MyThread28 test = new MyThread28();
    for(int i=0;i<10;i++){
      new Thread(){
        public void run() {
          for(int j=0;j<1000;j++)
            test.increase();
          countDownLatch.countDown();
        }
      }.start();
    }
    countDownLatch.await();
    System.out.println(test.inc);
  }
}

運行結(jié)果如下

每次運行結(jié)果都不一致。剛才我已經(jīng)解釋過，這里我再解釋一遍。

使用volatile修飾int型變量i，多個線程同時進行i++操作。比如有兩個線程A和B對volatile修飾的i進行i++操作，i的初始值是0，A線程執(zhí)行i++時從本地內(nèi)存剛讀取了i的值0（i++不是原子操作），就切換到B線程了，B線程從本地內(nèi)存中讀取i的值也為0，然后就切換到A線程繼續(xù)執(zhí)行i++操作，完成后i就為1了，接著切換到B線程，因為之前已經(jīng)讀取過了，所以繼續(xù)執(zhí)行i++操作，最后的結(jié)果i就為1了。同理可以解釋為什么每次運行結(jié)果都是小于10000的數(shù)字。

解決方法：

使用synchronized關(guān)鍵字

public class MyThread28 {
  //使用CountDownLatch來等待計算線程執(zhí)行完
  static CountDownLatch countDownLatch = new CountDownLatch(10);
  public int inc = 0;
  public synchronized void increase() {
    inc++;
  }
  public static synchronized void main(String[] args) throws InterruptedException {
    final MyThread28 test = new MyThread28();
    for(int i=0;i<10;i++){
      new Thread(){
        public void run() {
          for(int j=0;j<1000;j++)
            test.increase();
          countDownLatch.countDown();
        }
      }.start();
    }
    countDownLatch.await();
    System.out.println(test.inc);
  }
}

輸出結(jié)果如下

synchronized不管是否是原子操作，它能保證同一時刻只有一個線程獲取鎖執(zhí)行同步代碼，會阻塞其他線程。

結(jié)論：