作者：LouisWong
來源：https://my.oschina.net/u/1753415/blog/724242
Java中long和double的原子性
java中基本型別中，long和double的長度都是8個位元組，32位（4位元組）處理器對其讀寫操作無法一次完成，那么，JVM，long和double是原子性的嗎？
JVM中對long的操作是不是原子操作？
首先，通過一段程式對long的原子性進行判斷，測驗程式如下：
public class LongAtomTest implements Runnable {
private static long field = 0;
private volatile long value;
public long getValue() {
return value;
}
public void setValue(long value) {
this.value = https://www.cnblogs.com/javastack/archive/2021/06/30/value;
}
public LongAtomTest(long value) {
this.setValue(value);
}
@Override
public void run() {
int i = 0;
while (i < 100000) {
LongAtomTest.field = this.getValue();
i++;
long temp = LongAtomTest.field;
if (temp != 1L && temp != -1L) {
System.out.println("出現錯誤結果" + temp);
System.exit(0);
}
}
System.out.println("運行正確");
}
public static void main(String[] args) throws InterruptedException {
// 獲取并列印當前JVM是32位還是64位的
String arch = System.getProperty("sun.arch.data.model");
System.out.println(arch+"-bit");
LongAtomTest t1 = new LongAtomTest(1);
LongAtomTest t2 = new LongAtomTest(-1);
Thread T1 = new Thread(t1);
Thread T2 = new Thread(t2);
T1.start();
T2.start();
T1.join();
T2.join();
}
}
可以看到，程式中有兩條執行緒t1,t2； t1,t2各自不停的給long型別的靜態變數field賦值為1，-1； t1,t2每次賦值后，會讀取field的值，若field值既不是1又不是-1，就將field的值列印出來
如果對long的寫入和讀取操作是原子性的，那么，field的值只可能是1或者-1
運行結果如下
32-bit
出現錯誤結果-4294967295
運行正確
可以看出，當執行緒t1,t2同時對long進行寫的時候，long出現了既不是t1寫入的值，又不是t2寫入的值，可以推測，jvm中對long的操作并非原子操作，
為什么對long的操作不是原子的？
JVM記憶體模型中定義了8中原子操作：
- lock:將一個變數標識為被一個執行緒獨占狀態
- unclock:將一個變數從獨占狀態釋放出來，釋放后的變數才可以被其他執行緒鎖定
- read:將一個變數的值從主記憶體傳輸到作業記憶體中，以便隨后的load操作
- load:把read操作從主記憶體中得到的變數值放入作業記憶體的變數的副本中
- use:把作業記憶體中的一個變數的值傳給執行引擎，每當虛擬機遇到一個使用到變數的指令時都會使用該指令
- assign:把一個從執行引擎接收到的值賦給作業記憶體中的變數，每當虛擬機遇到一個給變數賦值的指令時，都要使用該操作
- store:把作業記憶體中的一個變數的值傳遞給主記憶體，以便隨后的write操作
- write:把store操作從作業記憶體中得到的變數的值寫到主記憶體中的變數
其中，與賦值，取值相關的包括 read,load,use,assign,store,write
按照這個規定，long的讀寫都是原子操作，與我們的實踐結果相反，為什會導致這種問題呢？
對于32位作業系統來說，單次次操作能處理的最長長度為32bit，而long型別8位元組64bit，所以對long的讀寫都要兩條指令才能完成（即每次讀寫64bit中的32bit），如果JVM要保證long和double讀寫的原子性，勢必要欄位外的處理， 那么，JVM有對這一情況進行額外處理嗎？ 針對這一問題可以參考Java語言規范檔案：jls-17 Non-Atomic Treatment of double and long
For the purposes of the Java programming language memory model, a single write to a non-volatile long or double value is treated as two separate writes: one to each 32-bit half. This can result in a situation where a thread sees the first 32 bits of a 64-bit value from one write, and the second 32 bits from another write.
Writes and reads of volatile long and double values are always atomic.
Writes to and reads of references are always atomic, regardless of whether they are implemented as 32-bit or 64-bit values.
Some implementations may find it convenient to divide a single write action on a 64-bit long or double value into two write actions on adjacent 32-bit values. For efficiency's sake, this behavior is implementation-specific; an implementation of the Java Virtual Machine is free to perform writes to long and double values atomically or in two parts.
Implementations of the Java Virtual Machine are encouraged to avoid splitting 64-bit values where possible. Programmers are encouraged to declare shared 64-bit values as volatile or synchronize their programs correctly to avoid possible complications.
從規定中我們可以知道：
- 對于64位的long和double，如果沒有被volatile修飾，那么對其操作可以不是原子的，在操作的時候，可以分成兩步，每次對32位操作，
- 如果使用volatile修飾long和double，那么其讀寫都是原子操作
- 對于64位的參考地址的讀寫，都是原子操作
- 在實作JVM時，可以自由選擇是否把讀寫long和double作為原子操作
- 推薦JVM實作為原子操作
從程式得到的結果來看，32位的HotSpot沒有把long和double的讀寫實作為原子操作， 在讀寫的時候，分成兩次操作，每次讀寫32位，因為采用了這種策略，所以64位的long和double的讀與寫都不是原子操作，
在硬體，作業系統，JVM都是64位的情況下呢？
對于64bit的環境來說，單次操作可以操作64bit的資料，即可以以一次性讀寫long或double的整個64bit，因此我們可以猜測，在64位的環境下，long和double的讀寫有可能是原子操作， 在換了64位的JVM之后，多次運行，結果都是正確的
64-bit
運行正確
運行正確
結果表明，在64bit的虛擬機下，long的處理是原子性的，
近期熱文推薦：
1.1,000+ 道 Java面試題及答案整理(2021最新版)
2.終于靠開源專案弄到 IntelliJ IDEA 激活碼了，真香！
3.阿里 Mock 工具正式開源，干掉市面上所有 Mock 工具！
4.Spring Cloud 2020.0.0 正式發布，全新顛覆性版本！
5.《Java開發手冊（嵩山版）》最新發布，速速下載！
覺得不錯，別忘了隨手點贊+轉發哦！
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/288718.html
標籤：其他