什么是 Volatile 變量鸠删？
Volatile 是 Java 中的一個關(guān)鍵字。你不能將它設(shè)置為變量或者方法名贼陶，句號刃泡。
認(rèn)真點(diǎn)，別開玩笑,什么是 Volatile 變量碉怔？我們應(yīng)該什么時候使用它烘贴？
哈哈，對不起撮胧，沒法提供幫助桨踪。
volatile 關(guān)鍵字的典型使用場景是在多線程環(huán)境下，多個線程共享變量芹啥，由于這些變量會緩存在 CPU 的緩存中锻离，為了避免出現(xiàn)內(nèi)存一致性錯誤而采用 volatile 關(guān)鍵字。
考慮下面這個生產(chǎn)者/消費(fèi)者的例子墓怀，我們每次生成/消費(fèi)一個元素：
public class ProducerConsumer {
private String value = "";
private boolean hasValue = false;
public void produce(String value) {
while (hasValue) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("Producing " + value + " as the next consumable");
this.value = value;
hasValue = true;
}
public String consume() {
while (!hasValue) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
String value = this.value;
hasValue = false;
System.out.println("Consumed " + value);
return value;
}
}
在上面的類中汽纠，produce 方法通過存儲參數(shù)來生成一個新的值，然后將 hasValue 設(shè)置為 true傀履。while 循環(huán)檢測標(biāo)識變量（hasValue）是否 true虱朵，true 表示一個新的值沒有被消費(fèi)，要求當(dāng)前線程睡眠（sleep）钓账，該睡眠一直循環(huán)直到標(biāo)識變量 hasValue 變?yōu)?false碴犬，只有在新的值被 consume 方法消費(fèi)完成后才能變?yōu)?false。如果沒有有效的新值官扣，consume 方法要求當(dāng)前睡眠翅敌，當(dāng)一個 produce 方法生成一個新值時羞福，睡眠循環(huán)終止惕蹄，并改變標(biāo)識變量的值。
現(xiàn)在想象有兩個線程在使用這個類的對象，一個生成值（寫線程）卖陵，另個一個消費(fèi)值（讀線程）遭顶。通過下面的測試來解釋這種方式：
public class ProducerConsumerTest {
public void testProduceConsume() throws InterruptedException {
ProducerConsumer producerConsumer = new ProducerConsumer();
List<String> values = Arrays.asList("1", "2", "3", "4", "5", "6", "7", "8",
"9", "10", "11", "12", "13");
Thread writerThread = new Thread(() ->
values.stream().forEach(producerConsumer::produce)
);
Thread readerThread = new Thread(() -> {
for (int i = 0; i < values.size(); i++) {
producerConsumer.consume();
}
});
writerThread.start();
readerThread.start();
writerThread.join();
readerThread.join();
}
}
這個例子大部分時候都能輸出期望的結(jié)果，但是也有很大概率會出現(xiàn)死鎖泪蔫！
怎么會棒旗？
我們先簡單討論一下計算機(jī)的結(jié)構(gòu)。
我們都知道計算機(jī)是由內(nèi)存單元和 CPU （還有許多其他部分）組成撩荣。主內(nèi)存就是程序指令铣揉、變量、數(shù)據(jù)存儲的地方餐曹。程序執(zhí)行期間逛拱，為了獲得更好的性能，CPU 可能會將變量拷貝到自己的內(nèi)存中（即所謂的 CPU 緩存）台猴。由于現(xiàn)代計算機(jī)有多個 CPU朽合，同樣也存在多個 CPU 緩存。
在多線程環(huán)境下饱狂，有可能多個線程同時執(zhí)行曹步，每個線程使用不同的 CPU（雖然這完全依賴于底層的操作系統(tǒng)），每個 CPU 都從主內(nèi)存中拷貝變量到它自己的緩存中休讳。當(dāng)一個線程訪問這些變量時讲婚，是直接訪問緩存中的副本，而不是真正訪問主內(nèi)存中的變量衍腥。
現(xiàn)在磺樱，假設(shè)在我們的測試中有兩個線程運(yùn)行在不同的 CPU 上，并且其中的有一個緩存了標(biāo)識變量（或者兩個都緩存了）∑畔蹋現(xiàn)在考慮如下的執(zhí)行順序
- 寫線程生成一個值竹捉，并將 hasValue 設(shè)置為 true。但是只更新緩存中的值尚骄，而不是主內(nèi)存块差。
- 讀線程嘗試消費(fèi)一個值，但是它的緩存副本中 hasValue 被設(shè)置為 false倔丈，所以即使寫線程生產(chǎn)了一個新的值憨闰，也不能被消費(fèi)，因為讀線程無法跳出睡眠循環(huán)（hasValue 的值為 false）需五。
- 因為讀線程不能消費(fèi)新生成的值鹉动，所以寫線程也不能繼續(xù)，因為標(biāo)識變量沒有設(shè)置回 false宏邮，因此寫線程阻塞在睡眠循環(huán)中泽示。
- 這樣缸血，就產(chǎn)生了死鎖！
這種情況只有在 hasValue 同步到所有緩存才能改變械筛，這完全依賴于底層的操作系統(tǒng)捎泻。
那怎么解決這個問題？ volatile 怎么會適合這個例子埋哟？
如果我們將 hasValue 標(biāo)示為 volatile笆豁，我就能確定這種死鎖就不會再發(fā)生。
private volatile boolean hasValue = false;
volatile 變量強(qiáng)制線程每次讀取的時候都直接從主內(nèi)存中讀取赤赊，同時每次寫volatile 變量的時候也要立即刷新主內(nèi)存中的值闯狱。如果線程決定緩存變量，就需要每次讀寫的時候都與主內(nèi)存進(jìn)行同步抛计。
做這個改變之后扩氢，我們再來考慮前面導(dǎo)致死鎖的執(zhí)行步驟
寫線程生成一個值，并將 hasValue 設(shè)置為 true爷辱，這次直接更新主內(nèi)存中的值（即使這個變量被緩存了）录豺。
2.讀線程嘗試消費(fèi)一個值，先檢查 hasValue 的值饭弓，每次讀取都強(qiáng)制直接從主內(nèi)存中獲取值双饥，所以能獲取到寫線程改變后的值。讀線程消費(fèi)完生成的值后弟断，重新設(shè)置標(biāo)識變量的值咏花，這個新的值也會同步到主內(nèi)存（如果這個值被緩存了，緩存的副本也會更新）阀趴。
寫線程獲每次都是從主內(nèi)存中取這個改變了的值昏翰，這樣就能繼續(xù)生成新的值。
現(xiàn)在刘急，大家都很幸福了_ !
我知道了棚菊，強(qiáng)制線程直接從內(nèi)存中讀寫線程，這是 Volatile 所能做全部的事情嗎叔汁？
實(shí)際上统求，它還有更多的功能。訪問一個 volatile 變量會在語句間建立 happens-before 關(guān)系据块。
什么是 happens-before 關(guān)系码邻？
happens-before 關(guān)系是程序語句之間的排序保證，這能確保任何內(nèi)存的寫另假，對其他語句都是可見的像屋。
這與 Volatile 是怎么關(guān)聯(lián)的？
當(dāng)寫一個 volatile 變量時边篮，隨后對該變量讀時會創(chuàng)建一個 happens-before 關(guān)系己莺。所以因苹，所有在 volatile 變量寫操作之前完成的寫操作，將會對隨后該 volatile 變量讀操作之后的所有語句可見篇恒。
嗯…,好吧…，我有點(diǎn)明白了凶杖，但是可能通過一個例子會更清楚胁艰。
好，對這個模糊的概念我表示很抱歉智蝠√诿矗考慮下面這個例子：
// Definition: Some variables
// 變量定義
private int first = 1;
private int second = 2;
private int third = 3;
private volatile boolean hasValue = false;
// First Snippet: A sequence of write operations being executed by Thread 1
//片段 1：線程 1 順序的寫操作
first = 5;
second = 6;
third = 7;
hasValue = true;
// Second Snippet: A sequence of read operations being executed by Thread 2
//片段 2：線程 2 順序的讀操作
System.out.println("Flag is set to : " + hasValue);
System.out.println("First: " + first); // will print 5 打印 5
System.out.println("Second: " + second); // will print 6 打印 6
System.out.println("Third: " + third); // will print 7 打印 7
我們假設(shè)上面的兩個代碼片段有由兩個線程執(zhí)行：線程 1 和線程 2。當(dāng)?shù)谝粋€線程改變 hasValue 的值時杈湾，它不僅僅是刷新這個改變的值到主存解虱，也會引起前面三個值的寫（之前任何的寫操作）刷新到主存。結(jié)果漆撞，當(dāng)?shù)诙€線程訪問這三個變量的時候殴泰，就可以訪問到被線程 1 寫入的值，即使這些變量之前被緩存（這些緩存的副本都會被更新）浮驳。
這就是為什么我們不需要像第一個示例一樣將變量標(biāo)示為 volatile 悍汛。因為我們的寫操作在訪問 hasValue 之前，讀操作在 hasValue 的讀之后至会，它會自動與主內(nèi)存同步离咐。
還有另一個有趣的結(jié)論。JVM 因它的程序優(yōu)化機(jī)制而聞名奉件。有時對程序語句的重排序可以大幅度提高性能宵蛀，并且不會改變程序的輸出結(jié)果。例如县貌，它可能會修改如語句的順序：
first = 5; second = 6; third = 7;
為：
second = 6;
third = 7;
first = 5;
但是术陶，當(dāng)多條語句涉及到對 volatile 變量的訪問時，它永遠(yuǎn)不會將 volatile 變量前的寫語句放在 volatile 變量之后煤痕，意思就是瞳别，它永遠(yuǎn)不會轉(zhuǎn)換下列順序：
first = 5; // write before volatile write //volatile 寫之前的寫
second = 6; // write before volatile write //volatile 寫之前的寫
third = 7; // write before volatile write //volatile 寫之前的寫
hasValue = true;
為：
first = 5;
second = 6;
hasValue = true;
third = 7; // Order changed to appear after volatile write! This will never happen!
third = 7; // 順序發(fā)生了改變，出現(xiàn)在了 volatile 寫之后杭攻。這永遠(yuǎn)不會發(fā)生祟敛。
即使從程序的正確性的角度來說，上面兩種情況是相等的兆解。但請注意馆铁，JVM 仍然允許對前三個變量的寫操作進(jìn)行重排序，只要它們都出現(xiàn)在 volatile 寫之前即可锅睛。
類似的埠巨，JVM 也不會將 volatile 變量讀之后的讀操作重排序到 volatile 變量之前历谍。意思就是說，下面的順序：
System.out.println("Flag is set to : " + hasValue); // volatile read //volatile 讀
System.out.println("First: " + first); // Read after volatile read // volatile 讀之后的讀
System.out.println("Second: " + second); // Read after volatile read// volatile 讀之后的讀
System.out.println("Third: " + third); // Read after volatile read// volatile 讀之后的讀
JVM 永遠(yuǎn)不會轉(zhuǎn)換為如下的順序：
System.out.println("First: " + first); // Read before volatile read! Will never happen! //volatile 讀之前的讀辣垒！永遠(yuǎn)不可能出現(xiàn)望侈！
System.out.println("Fiag is set to : " + hasValue); // volatile read //volatile 讀
System.out.println("Second: " + second);
System.out.println("Third: " + third);
但是，JVM 也有可能會對最后的三個讀操作重排序勋桶，只要它們在 volatile 變量讀之后即可脱衙。
我感覺 Volatile 變量會對性能有一定的影響。
你的感覺是對的例驹，因為 volatile 變量強(qiáng)制訪問主存捐韩，而訪問主存肯定被訪問 CPU 緩存慢。同時鹃锈，它還防止 JVM 對程序的優(yōu)化荤胁，這也會降低性能。
我們總能用 Volatile 變量來維護(hù)多線程之間的數(shù)據(jù)一致性嗎屎债？
非常不幸仅政，這是不行的。當(dāng)多個線程讀寫同一個變量時盆驹，僅僅靠 volatile 是不足以保證一致性的已旧，考慮下面這個 UnsafeCounter 類：
public class UnsafeCounter {
private volatile int counter;
public void inc() {
counter++;
}
public void dec() {
counter--;
}
public int get() {
return counter;
}
}
測試如下：
public class UnsafeCounterTest {
public void testUnsafeCounter() throws InterruptedException {
UnsafeCounter unsafeCounter = new UnsafeCounter();
Thread first = new Thread(() -> {
for (int i = 0; i < 5; i++) {
unsafeCounter.inc();
}
});
Thread second = new Thread(() -> {
for (int i = 0; i < 5; i++) {
unsafeCounter.dec();
}
});
first.start();
second.start();
first.join();
second.join();
System.out.println("Current counter value: " + unsafeCounter.get());
}
}
這段代碼具有非常好的自說明性。一個線程增加計數(shù)器召娜，另一個線程將計數(shù)器減少同樣次數(shù)运褪。運(yùn)行這個測試，期望的結(jié)果是計數(shù)器的值為 0玖瘸，但這無法得到保證秸讹。大部分時候是 0，但有的時候是 -1, -2, 1, 2 等雅倒，任何位于[-5, 5]之間的整數(shù)都有可能璃诀。
為什么會發(fā)生這種情況?這是因為對計數(shù)器的遞增和遞減操作都不是原子的——它們不是一次完成的。這兩種操作都由多個步驟組成蔑匣，這些步驟可能相互交叉劣欢。
你可以認(rèn)為遞增操作如下：
- 讀取計數(shù)器的值
- 加 1
- 將新的值寫回計數(shù)器
遞減操作的過程如下：
- 讀取計數(shù)器的值
- 減 1
- 將新的值寫回計數(shù)器
現(xiàn)在我們考慮一下如下的執(zhí)行步驟
- 第一個線程從主存中讀取計數(shù)器的值，初始值是 0裁良，然后加 1
- 第二個線程也從主存中讀取計數(shù)器的值凿将，它讀取到的值也是 0，然后進(jìn)行減 1 操作
- 第一線程將新的計數(shù)器的值寫回內(nèi)存价脾，將值設(shè)置為 1
- 第二個線程也將新的值寫回內(nèi)存牧抵，將值設(shè)置為 -1
怎么防止這類事件的發(fā)生？
使用同步
public class SynchronizedCounter {
private int counter;
public synchronized void inc() {
counter++;
}
public synchronized void dec() {
counter--;
}
public synchronized int get() {
return counter;
}
}
使用 AtomicInteger
public class AtomicCounter {
private AtomicInteger atomicInteger = new AtomicInteger();
public void inc() {
atomicInteger.incrementAndGet();
}
public void dec() {
atomicInteger.decrementAndGet();
}
public int get() {
return atomicInteger.intValue();
}
}
我個人的選擇是使用 AtomicInteger，因為 synchronized 只允許一個線程訪問 inc/get/get 方法犀变，對性能影響較大妹孙。
我注意到采用 Synchronized 的版本并沒有將計數(shù)器標(biāo)識為 volatile，難道這意味著……?
對的获枝。使用 synchronized 關(guān)鍵字也會在語句之間建立 happens-before 關(guān)系蠢正。進(jìn)入一個同步方法或塊時，會將之前的語句和該方法或塊內(nèi)部的語句建立 happens-before 關(guān)系省店。
查看完整的建立 happens-before 關(guān)系的情況列表嚣崭，請查看這里：
https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/package-summary.html#MemoryVisibility
