欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

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

 更新時(shí)間：2019年09月06日 09:47:01   作者：慢慢來(lái)  
這篇文章主要介紹了Java多線程 volatile關(guān)鍵字詳解,文中通過(guò)示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友可以參考下

volatile

volatile是一種輕量同步機(jī)制。請(qǐng)看例子

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("進(jìn)入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("已設(shè)置為false");
  }
}

輸出結(jié)果如下

進(jìn)入run了
已設(shè)置為false

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

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

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

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

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

在isRunning前加上volatile

private volatile boolean isRunning = true;

輸出結(jié)果如下

進(jìn)入run了
已設(shè)置為false
線程被停止了

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

先看例子

MyThread26_0類，用volatile修飾num

public class MyThread26_0 extends Thread {
  public static volatile int num = 0;
  //使用CountDownLatch來(lái)等待計(jì)算線程執(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];
    //開(kāi)啟30個(gè)線程進(jìn)行累加操作
    for(int i=0;i<mt.length;i++){
      mt[i] = new MyThread26_0();
    }
    for(int i=0;i<mt.length;i++){
      mt[i].start();
    }
    //等待計(jì)算線程執(zhí)行完
    countDownLatch.await();
    System.out.println(num);
  }
}

輸出結(jié)果如下

25886

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

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

結(jié)論：

volatile只會(huì)對(duì)單個(gè)的的變量讀寫具有原子性，像num++這種復(fù)合操作volatile是無(wú)法保證其原子性的

解決方法：

用原子類AtomicInteger的incrementAndGet方法自增

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

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

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

輸出結(jié)果如下

30000

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

例子如下

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...，因?yàn)閍ddAndGet方法和getAndAdd方法構(gòu)成的addNum不是原子操作。
解決該問(wèn)題只需要在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解決的是變量在多個(gè)線程之間的可見(jiàn)性，但是無(wú)法保證原子性。
synchronized不僅保障了原子性外，也保障了可見(jiàn)性。

volatile和synchronized比較

先看實(shí)例，使用volatile是什么效果

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

public class MyThread28 {
  //使用CountDownLatch來(lái)等待計(jì)算線程執(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);
  }
}

運(yùn)行結(jié)果如下

9677

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

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

解決方法：

使用synchronized關(guān)鍵字

public class MyThread28 {
  //使用CountDownLatch來(lái)等待計(jì)算線程執(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é)果如下

10000

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

結(jié)論：

  • volatile只能用在變量，synchronized可以在變量、方法上使用。
  • volatile不會(huì)造成線程阻塞，synchronized會(huì)造成線程阻塞。
  • volatile效率比synchronized高。

以上就是本文的全部?jī)?nèi)容，希望對(duì)大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。

相關(guān)文章

最新評(píng)論