詳解Java并發編程基礎之volatile
a）線程通信的機制主要有兩種：共享內存和消息傳遞。
①共享內存：線程之間共享程序的公共狀態，通過寫-讀共享內存中的公共狀態來進行隱式通信；
②消息傳遞：線程之間沒有公共狀態，線程之間 必須通過發送消息來顯式通信。
b）同步：用于控制不同線程之間操作發生相對順序。在
共享內存模型中，同步是顯式的進行的，需要顯示的指定某個方法或者代碼塊在線程執行期間互斥進行。
消息傳遞模型中，由于消息的發送必定在消息的接受之前，所以同步是隱式的進行的。
c）Java并發采用的是共享內存模型，線程之間通信總是隱式的進行，而且這個通信是對程序員透明的。那么我們需要了解的是這個隱式通信的底層工作機制。
2、volatile的定義Java編程語言中允許線程訪問共享變量，為了確保共享變量能夠被準確和一致性的更新，線程應該確保通過排它鎖單獨獲得這個變量。
3、volatile的底層實現原理a）在編寫多線程程序中，使用volatile修飾的共享變量在進行寫操作的時候，編譯器生成的匯編代碼中會多出一條lock指令，這條lock指令的作用：
①將當前處理器緩存行中的數據寫回到系統內存 ②這個寫回內存的操作會使得其他CPU里緩存了該內存地址的數據無效b）參考下面的這張圖理解
a）首先我們來看對單個變量的讀/寫的實現（單個變量的情況可以看做是對同一個鎖對這個變量的讀/寫進行了同步），看下面的例子
package cn.jvm.test;public class TestVolatile1 { volatile long var1 = 0L; public void set(long l) {// TODO Auto-generated method stubvar1 = l; } public void getAndIncrement() {// TODO Auto-generated method stubvar1 ++; //注意++操作 } public long get() {return var1; }}
上面的set和get操作在語義上和使用synchronized修飾后一樣，即下面的這種寫法
package cn.jvm.test;public class TestVolatile1 { volatile long var1 = 0L; public synchronized void set(long l) {// TODO Auto-generated method stubvar1 = l; } public synchronized long get() {return var1; }}
b）但是在上面的用例中，我們使用的var1++操作，整體上沒有原子性，所以如果使用多線程方粉getAndIncrement方法的話，會導致讀出的數據和主存中不一致的情況。
c）volatile變量的特性
①可見性：對一個volatile變量的讀操作，總是能夠看到對這個volatile變量最后的寫入
②原子性：對任意單個volatile變量的讀寫具有原子性，但是對于volatile變量的復合型操作并不具備原子性
2、volatile寫-讀建立的happens-before關系a）看下面的代碼實例
package cn.jvm.test;public class TestVolatile2 { int a = 0; volatile boolean flag = false; public void writer() {a = 1;flag = true; } public void reader() {if(flag) { int i =a; //...其他操作} }}
b）在上面的程序中，假設線程A執行write方法，線程B執行reader方法，根據happens-before規則有下面的關系：
程序次序規則：①happens-before②； ③happens-before④
volatile規則：②happens-before③
傳遞性規則：①happens-before④
所以可以得到下面的這個狀態圖
a）下面是volatile的寫/讀內存語義
①當寫一個volatile變量時候，JMM會將線程對應的本地內存中的共享變量值刷新到主內存中
②當讀一個volatile變量的時候，JMM會將線程對應的本地內存置為無效，然后從主內存中讀取共享變量
b）還是參照上面的程序示例，參考視圖的模型來進行說明
①寫內存語義的示意圖：假設線程A執行writer方法，線程B執行reader方法，初始狀況下線程A和B中的變量都是初始狀態
②寫內存語義的示意圖：
我們上面說到的基本上從宏觀上而言都是說明了volatile保證內存可見性問題，volatile的另一個語義就是禁止指令重排序的優化。下面說一下volatile禁止指令重排序的實現細節
1、volatile重排序規則①當第二個操作是volatile寫的時候，不管第一個操作是什么，都不能進行指令重排序。這個規則確保volatile寫之前的操作都不會被重排序到volatile寫之后。也是為了保證volatile寫對其他線程可見
②當第一個操作為volatile讀的時候，不管第二個操作是什么，都不能進行重排序。確保volatile讀之后的操作不會被重排序到volatile讀之前
③當第一個操作是volatile寫，第二個操作是volatile讀的時候，不能進行重排序
如下所示，上面的是下表中的總結。
編譯器在生成字節碼的時候，會在指令序列中插入內存屏障來禁止對特定類型的處理器重排序。下面是集中策略，后面會說明這幾種情況
①在每個volatile寫操作之前插入StoreStore屏障
②在每個volatile寫操作之后插入StoreLoad屏障
③在每個volatile讀操作之后插入LoadLoad屏障
④在每個volatile讀操作之后插入LoadStore屏障
3、內存屏障示例a）volatile寫插入內存屏障之后的指令序列圖
b）volatile讀插入內存屏障后的指令序列圖
1、先看下面的示例代碼，觀察運行結果，當共享變量isRunning沒有被聲明為volatile的時候，main線程會在2秒之后將共享變量isRunning置為false并且輸出修改信息，這樣新建的線程應該結束運行，但是實際上并沒有，控制臺中會一直保持運行的狀態，并且不會打印線程結束執行；如下所示
package cn.jvm.test;class ThreadDemo extends Thread { private boolean isRunning = true; @Override public void run() {System.out.println(Thread.currentThread().getName() + ' 開始執行');while(isRunning) {}System.out.println(Thread.currentThread().getName() + ' 結束執行'); } public boolean isRunning() {return isRunning; } public void SetIsRunning(boolean isRunning) {this.isRunning = isRunning; }}public class TestVolatile4 { public static void main(String[] args) {ThreadDemo td = new ThreadDemo();td.start();try { Thread.sleep(2000); td.SetIsRunning(false); System.out.println(Thread.currentThread().getName() + ' 線程將共享變量值修改為false');} catch (Exception e) { // TODO: handle exception e.printStackTrace();} }}
2、分析出現上面結果的原因
在啟動線程ThreadDemo之后，變量isRunning被存在公共堆棧以及線程的私有堆棧中，后//續中線程一直在私有堆棧中取出isRunning的值，雖然main線程執行SetIsRunning方法修改了isRunning的值，但是這個值并沒有被Thread-//0線程所知，就像上面說的Thread-0取得值一直都是私有堆棧中的，所以不會知道isRunning被修改，也就不會退出循環
3、按照上面的原因分析一下執行的時候的工作內存和主內存的情況，按照下面的分析我們很容易得出結論
上面的問題就是因為工作內存（私有堆棧）和主內存（公共堆棧）中的值不同步。而按照我們上面說到的volatile使得單個變量保證線程可見性，就可以對程序修改保證共享變量在main線程中的修改對Thread-0線程可見（結合volatile的實現原理）
4、修改之后的結果
package cn.jvm.test;class ThreadDemo extends Thread { private volatile boolean isRunning = true; @Override public void run() {System.out.println(Thread.currentThread().getName() + ' 開始執行');while(isRunning) { }System.out.println(Thread.currentThread().getName() + ' 結束執行'); } public boolean isRunning() {return isRunning; } public void SetIsRunning(boolean isRunning) {this.isRunning = isRunning; }}public class TestVolatile4 { public static void main(String[] args) {ThreadDemo td = new ThreadDemo();td.start();try { Thread.sleep(2000); td.SetIsRunning(false); System.out.println(Thread.currentThread().getName() + ' 線程將共享變量值修改為false');} catch (Exception e) { // TODO: handle exception e.printStackTrace();} }}
1、volatile能保證對單個變量在多線程之間的可見性問題，但是對于單個變量的復合操作不能保證原子性，如下代碼示例，運行結果為
當然這個結果是隨機的，但是不能保證運行結果是100000
在沒有使用同步操作之前，雖然count變量是volatile的，但是由于count++操作是個復合操作
①從內存中取出count的值
②計算count的值
③將count的值寫到內存中
這個復合操作由于volatile不能保證原子性，所以就會出現錯誤
package cn.jvm.test;import java.util.ArrayList;import java.util.List;public class TestVolatile5 { volatile int count = 0; /*synchronized*/ void m(){for(int i = 0; i < 10000; i++){ count++;} } public static void main(String[] args) {final TestVolatile5 t = new TestVolatile5();List<Thread> threads = new ArrayList<>();for(int i = 0; i < 10; i++){ threads.add(new Thread(new Runnable() {@Overridepublic void run() { t.m();} }));}for(Thread thread : threads){ thread.start();}for(Thread thread : threads){ try {thread.join(); } catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace(); }}System.out.println(t.count); }}
2、下面按照JVM的內存工作來分析一下，即當前一個線程在計算count變量的時候，另一個線程已經修改了count變量的值，這樣就必然會出現錯誤。所以對于這種復合操作就需要使用原子類或者使用synchronized來保證原子性（保證同步）
3、修改后的synchronized和使用原子類如下所示
package cn.jvm.test; import java.util.ArrayList; import java.util.List; public class TestVolatile5 { int count = 0; synchronized void m(){ for(int i = 0; i < 10000; i++){ count++; } } public static void main(String[] args) { final TestVolatile5 t = new TestVolatile5(); List<Thread> threads = new ArrayList<>(); for(int i = 0; i < 10; i++){ threads.add(new Thread(new Runnable() { @Override public void run() { t.m(); } })); } for(Thread thread : threads){ thread.start(); } for(Thread thread : threads){ try { thread.join(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } System.out.println(t.count); } }
package cn.jvm.test; import java.util.ArrayList; import java.util.List; import java.util.concurrent.atomic.AtomicInteger; public class TestVolatile5 { AtomicInteger count = new AtomicInteger(0); void m(){ for(int i = 0; i < 10000; i++){ count.getAndIncrement(); } } public static void main(String[] args) { final TestVolatile5 t = new TestVolatile5(); List<Thread> threads = new ArrayList<>(); for(int i = 0; i < 10; i++){ threads.add(new Thread(new Runnable() { @Override public void run() { t.m(); } })); } for(Thread thread : threads){ thread.start(); } for(Thread thread : threads){ try { thread.join(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } System.out.println(t.count); } }
以上就是詳解Java并發編程基礎之volatile的詳細內容，更多關于Java 并發編程 volatile的資料請關注好吧啦網其它相關文章！
相關文章：
網公網安備