一、簡介
在上篇文章中,我們介紹到在多線程環境下,如果編程不當,可能會出現程序運行結果混亂的問題。
出現這個原因主要是,JMM 中主內存和線程工作內存的數據不一致,以及多個線程執行時無序,共同導致的結果。
同時也提到引入synchronized
同步鎖,可以保證線程同步,讓多個線程依次排隊執行被synchronized
修飾的方法或者方法塊,使程序的運行結果與預期一致。
不可否認,採用synchronized
同步鎖確實可以保證線程安全,但是它對服務性能的消耗也很大,synchronized
是一個獨佔式的同步鎖,比如當多個線程嘗試獲取鎖時,其中一個線程獲取到鎖之後,未獲取到鎖的線程會不斷的嘗試獲取鎖,而不會發生中斷,當衝突嚴重的時候,線程會直接進入阻塞狀態,不能再幹別的活。
爲了實現線程之間更加方便的訪問共享變量,Java 編程語言還提供了另一種同步機制:volatile
域變量,在某些場景下使用它會更加方便。
一般來說,被volatile
修飾的變量,可以保證所有線程看到這個變量都是同一個值,同時它不會引起線程上下文的切換和調度,相比synchronized
,volatile
更加的輕量化。
比較官方的解釋,volatile
修飾變量有以下幾個作用:
-
1.保證變量的可見性,不保證原子性
當用volatile
修飾一個變量時,JMM 會把當前線程本地內存中的變量強制刷新到主內存中去,這個寫操作也會導致其他線程中被volatile
修飾的變量緩存無效,然後從主內存中獲取最新的值 -
2.禁止指令重排
正常情況下,編譯器和處理器爲了優化程序執行性能會對指令序列進行重排序,當然是在不影響程序結果的前提下。volatile
能夠在一定程度上禁止 JVM 進行指令重排。
從概念上感覺比較難理解,下面我們結合幾個例子,一起來看看它的具體應用。
二、volatile 使用詳解
我們先看一個例子。
public class DataEntity {
private boolean isRunning = true;
public void addCount(){
System.out.println("線程運行開始....");
while (isRunning){ }
System.out.println("線程運行結束....");
}
public boolean isRunning() {
return isRunning;
}
public void setRunning(boolean running) {
isRunning = running;
}
}
public class MyThread extends Thread {
private DataEntity entity;
public MyThread(DataEntity entity) {
this.entity = entity;
}
@Override
public void run() {
entity.addCount();
}
}
public class MyThreadTest {
public static void main(String[] args) throws InterruptedException {
// 初始化數據實體
DataEntity entity = new DataEntity();
MyThread threadA = new MyThread(entity);
threadA.start();
// 主線程阻塞1秒
Thread.sleep(1000);
// 將運行狀態設置爲false
entity.setRunning(false);
}
}
運行結果如下:
從實際運行結果來看,程序進入死循環狀態,雖然最後一行手動設置了entity.setRunning(false)
,但是沒有起到任何的作用。
原因其實也很簡單,雖然主線程main
將isRunning
變量設置爲false
,但是線程threadA
裏面的isRunning
變量還是true
,兩個線程看到的數據不一致。
假如在isRunning
變量上,加一個volatile
關鍵字,我們再來看看運行效果。
/**
* 在 isRunning 變量上加一個 volatile 關鍵字
*/
private volatile boolean isRunning = true;
運行結果如下:
程序運行後自動結束。
說明當主線程main
將isRunning
變量設置爲false
時,線程threadA
裏面的isRunning
值也隨着發生變化。
說明被volatile
修飾的變量,在多線程環境下,可以保證所有線程看到這個變量都是同一個值。
三、volatile 不適用的場景
對於某些場景下,volatile
可能並不適用,我們還是先看一個例子。
public class DataEntity {
private volatile int count = 0;
public void addCount(){
for (int i = 0; i < 100000; i++) {
count++;
}
}
public int getCount() {
return count;
}
}
public class MyThreadTest {
public static void main(String[] args) throws InterruptedException {
// 初始化數據實體
DataEntity entity = new DataEntity();
// 初始化5個線程計數器
CountDownLatch latch = new CountDownLatch(5);
// 採用多線程進行操作
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
entity.addCount();
//線程運行完畢減1
latch.countDown();
}
}).start();
}
// 等待以上線程執行完畢,再獲取結果
latch.await();
System.out.println("result: " + entity.getCount());
}
}
運行結果如下:
第一次運行:result: 340464
第二次運行:result: 318342
第三次運行:result: 305957
理論上使用 5 個線程分別執行了100000
自增,我們預期的結果應該是5*100000=500000
,從實際的運行結果可以看出,與預期不一致。
這是因爲volatile
的作用其實是有限的,它只能保證多個線程之間看到的共享變量值是最新的,但是無法保證多個線程操作共享變量時依次有序,無法保證原子性操作。
上面的例子中count++
不是一個原子性操作,在處理器看來,其實一共做了三個步驟的操作:讀取數據、對數據加 1、回寫數據,在多線程隨機執行情況下,輸出結果不能達到預期值。
如果想要實現與預期一致的結果,有以下三種方案可選。
方案一:採用synchronized
同步鎖
public class DataEntityC2 {
private int count = 0;
/**
* 採用 synchronized 同步鎖,可以實現多個線程執行方法時串行
*/
public synchronized void addCount(){
for (int i = 0; i < 100000; i++) {
count++;
}
}
public int getCount() {
return count;
}
}
方案二:採用Lock
鎖
public class DataEntityC2 {
private int count = 0;
private Lock lock = new ReentrantLock();
/**
* 採用 Lock 鎖,可以實現多個線程執行方法時串行
*/
public void addCount(){
for (int i = 0; i < 100000; i++) {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
}
public int getCount() {
return count;
}
}
方案三:採用JUC
包中的原子操作類
public class DataEntity {
private AtomicInteger inc = new AtomicInteger();
/**
* 採用原子操作類,原子操作類是通過CAS循環的方式來保證操作原子性
*/
public void addCount(){
for (int i = 0; i < 100000; i++) {
inc.getAndIncrement();
}
}
public int getCount() {
return inc.get();
}
}
以上三種方案,都可以實現程序的運行結果與預期一致!
四、volatile 的原理
通過以上的例子介紹,相信大家對volatile
關鍵字的作用有了一些認識。
volatile
修飾的變量,可以保證變量在內存中的可見性,但是無法保證原子性操作。
關於原子性、可見性和有序性的定義,這三個特性主要從多線程編程安全角度總結出來的一些基本要素,也是併發編程的三大核心基礎,在上篇文章中有所提到過,這裏不再重複講了。
在 JVM 底層,volatile
是通過採用“內存屏障”來實現內存可見性和禁止指令重排。觀察不加入volatile
和加入volatile
關鍵字所生成的彙編代碼發現,加入volatile
關鍵字的代碼會多出一個lock
前綴指令,lock
前綴指令實際上相當於一個內存屏障,可以提供以下 3 個功能。
- 1.它確保指令重排序時,不會把後面的指令排到內存屏障之前的位置,也不會把前面的指令排到內存屏障的後面,禁止處理器對影響程序執行結果的指令進行重排
- 2.它會強制將緩存的修改操作立刻寫入主存,保證內存變量可見
- 3.如果是寫操作,它會導致其它 CPU 中對應的行緩存無效,目的是讓其他線程中被
volatile
修飾的變量緩存無效,然後從主內存中獲取最新的值
五、單例模式中的雙重檢鎖爲什麼要加 volatile?
在上篇文章中,我們提到過單例設計模式中的雙重校驗鎖實現。
public class Singleton {
private volatile static Singleton singleton;
private Singleton (){}
public static Singleton getSingleton() {
if (singleton == null) { //第一行
synchronized (Singleton.class) { //第二行
if (singleton == null) { //第三行
singleton = new Singleton(); //第四行
}
}
}
return singleton; //第五行
}
}
synchronized
可以保證原子性、可見性和有序性,爲什麼變量singleton
還需要加volatile
關鍵字呢?
之所以需要加volatile
關鍵字的原因是:問題出在第一行代碼不在同步代碼塊之類,可能出現這個對象地址不爲空,但是內容爲空。
以初始化一個Singleton singleton = new Singleton();
爲例,JVM 會分三個步驟完成:
a. memory = allocate() //分配內存
b. ctorInstanc(memory) //初始化對象
c. instance = memory //設置instance指向剛分配的地址
上面的代碼在編譯運行時可能會出現重排序,因爲b
和c
無邏輯關聯,執行的順序是a -> b -> c
或者a -> c -> b
,在多線程的環境下可能會出現問題。
分析過程如下:
- 1.線程 A 執行到第四行代碼時,線程 B 進來執行第一行代碼
- 2.假設線程 A 在執行過程中發生了指令重排序,先執行了
a
和c
,沒有執行b
- 3.由於線程 A 執行了
c
導致instance
指向了一段地址,此時線程 B 檢查singleton
發現不爲null
,會直接跳轉到第五行代碼,返回一個未初始化的對象,導致程序會出現報錯 - 4.因此需要在
singleton
變量上加一個volatile
關鍵字,當線程 A 執行完畢b
操作之後,會變量強制刷新到主內存中,此時線程 B 也可以拿到最新的對象
這就是爲啥雙重檢鎖模式中,singleton
變量爲啥要加一個volatile
關鍵字的原因。
採用雙重檢鎖的方式,可以顯著的提升併發查詢的效率。
六、小結
本篇文章主要圍繞volatile
關鍵字的用途、使用方式和一些坑點,做了一個簡單的知識總結,內容難免有所遺漏,歡迎網友留言指出!