對于volatile和synchronized的一些整理
目錄
對于volatile和synchronized的一些整理
從單例類引入
拋出問題：
定義與作用
拋出問題：
記憶體模型
舉個例子：i=i+1
總結：
記憶體可見性
總結：所以volatile的作用之一就是保證記憶體的可見性👇
精確地說就是編譯器在用到這個變數時必須每次都小心地重新讀取這個變數的值，而不是使用保存在暫存器里的備份，
暫存器
原子性：
總結：原子性
有序性
回頭看單例類
volatile與synchronized區別
總結：volatile和synchronized
單例類中雙重加鎖的原因
最后的補充：volatile和synchronized的有序性為什么不一樣
最后的最后的補充：volatile和記憶體屏障
參考文章
從單例類引入
這周遇到了關于單例類的書寫問題
發現懶漢式單例類具有執行緒不安全的問題
單例類主要分餓漢式單例類和懶漢式單例類
他們主要的區別就是 餓漢式單例類是空間換時間 懶漢式單例類是時間換空間
餓漢式單例類
/*餓漢式是典型的空間換時間
*類初始化時創建單例，執行緒安全，
*適?于單例占記憶體?的場景，
*否則推薦使?懶漢式延遲加載*/
public class EagerSingleton {
private static EagerSingleton instance = new EagerSingleton();
//靜態工廠方法
public static EagerSingleton getInstance() {
return instance;
}
private EagerSingleton(){}
}懶漢式單例類
/*懶漢式是典型的時間換空間
*需要創建單例實體的時候再創建，
* 需要考慮執行緒安全(性能不太好)*/
public class LazySingleton {
private static LazySingleton instance = null;
// 靜態工廠方法
public static LazySingleton getInstance() {
if (instance == null) {
instance = new LazySingleton();
}
return instance;
}
private LazySingleton() {
}
}*問題：執行緒不安全！
解決方法之一：雙重加鎖
public class Singleton {
private volatile static Singleton instance = null;
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if(instance==null){
//volatile關鍵字作用為禁止指令重排，保證回傳Singleton物件一定在創建物件后
instance = new Singleton();
}
}
}
return instance;
}
//volatile關鍵字作用為禁止指令重排，保證回傳Singleton物件一定在創建物件后
instance = new Singleton();
//instance=new Singleton陳述句為非原子性，實際上會執行以下內容：
//(1)在堆上開辟空間；(2)屬性初始化;(3)參考指向物件
//假設以上三個內容為三條單獨指令，因指令重排可能會導致執行順序為1->3->2(正常為1->2->3),當單例模
式中存在普通變數需要在構造方法中進行初始化操作時，單執行緒情況下，順序重排沒有影響；但在多執行緒情況
下，假如執行緒1執行instance=new Singleton()陳述句時先1再3，由于系統調度執行緒2的原因沒來得及執行步驟
2，但此時已有參考指向物件也就是instance!=null，故執行緒2在第一次檢查時不滿足條件直接回傳
instance，此時instance為null(即str值為null)
private Singleton() {
}
}拋出問題：
1.volatile是什么？作用是什么？
2.非原子性？禁止指令重排？
3.volatile怎么用？
volatile定義與作用
百科：
volatile是一個特征修飾符volatile的作用是作為指令關鍵字，確保本條指令不會因編譯器的優化而省略，且要求每次直接讀值，
精確地說就是，編譯器在用到這個變數時必須每次都小心地重新讀取這個變數的值，而不是使用保存在暫存器里的備份，
拋出問題：
編譯器？暫存器？
記憶體模型？
記憶體可見性
記憶體模型
定義:
JMM（Java Memory Model）：Java 記憶體模型，是 Java 虛擬機規范中所定義的一種記憶體模型，Java 記憶體模型是標準化的，屏蔽掉了底層不同計算機的區別，也就是說，JMM 是 JVM 中定義的一種并發編程的底層模型機制，
JMM 定義了執行緒和主記憶體之間的抽象關系：執行緒之間的共享變數存盤在主記憶體中，每個執行緒都有一個私有的本地記憶體，本地記憶體中存盤了該執行緒以讀/寫共享變數的副本，
講人話：
簡單來說就是java的多執行緒之間記憶體處理的一個規定
JMM（Java Memory Model）具體規定 ：
所有的共享變數都存盤于主記憶體，這里所說的變數指的是實體變數和類變數，不包含區域變數，因為區域變數是執行緒私有的，因此不存在競爭問題，
- 每一個執行緒還存在自己的作業記憶體，執行緒的作業記憶體(高速快取)，保留了被執行緒使用的變數的作業副本，
- 執行緒對變數的所有的操作（讀，取）都必須在作業記憶體中完成，而不能直接讀寫主記憶體中的變數，
- 不同執行緒之間也不能直接訪問對方作業記憶體中的變數，執行緒間變數的值的傳遞需要通過主記憶體中轉來完成，
簡單來說就是：東西只有一份 你們不可以直接拿 你們先復印一下 在自己的復印件上面動手腳 并且你們還不能互相抄作業
為什么？
為了解決：
計算機在執行程式時，每條指令都是在CPU中執行的，而執行指令程序中，勢必涉及到資料的讀取和寫入，由于程式運行程序中的臨時資料是存放在主存（物理記憶體）當中的，這時就存在一個問題，由于CPU執行速度很快，而從記憶體讀取資料和向記憶體寫入資料的程序跟CPU執行指令的速度比起來要慢的多，因此如果任何時候對資料的操作都要通過和記憶體的互動來進行，會大大降低指令執行的速度，因此在CPU里面就有了高速快取，
舉個例子：i=i+1
當執行緒執行這個陳述句時，會先從主存當中讀取i的值，然后復制一份到高速快取當中，然后CPU執行指令對i進行加1操作，然后將資料寫入高速快取，最后將高速快取中i最新的值重繪到主存當中，
但是多執行緒之中
比如同時有2個執行緒執行這段代碼，假如初始時i的值為0，那么我們希望兩個執行緒執行完之后i的值變為2，但是事實會是這樣嗎？
可能存在下面一種情況：初始時，兩個執行緒分別讀取i的值存入各自所在的CPU的高速快取當中，然后執行緒1進行加1操作，然后把i的最新值1寫入到記憶體，此時執行緒2的高速快取當中i的值還是0，進行加1操作之后，i的值為1，然后執行緒2把i的值寫入記憶體，
多執行緒中出現了快取不一致！
總結：
由于JMM記憶體模型的原因，多執行緒中可能會出現快取不一致的情況，解決這種問題就是所謂的保證了記憶體可見性
記憶體可見性
記憶體可見性是指當一個執行緒修改了某個變數的值，其它執行緒總是能知道這個
變數變化，也就是說，如果執行緒 A 修改了共享變數 X 的值，那么執行緒 B 在使用 X 的值時，能立即讀到 X 的最新值，
解決：加鎖或者是加volatile
總結：所以volatile的作用之一就是保證記憶體的可見性👇
精確地說就是編譯器在用到這個變數時必須每次都小心地重新讀取這個變數的值，而不是使用保存在暫存器里的備份，
對volatile變數執行寫操作時，會在寫操作后加入一條store屏障指令，
對volatile變數執行讀操作時，會在讀操作后加入一條load屏障指令，
而synchronized也同樣保證了記憶體的可見性
暫存器
百科：
暫存器的功能是存盤二進制代碼，它是由具有存盤功能的觸發器組合起來構成的，一個觸發器可以存盤1位二進制代碼，故存放n位二進制代碼的暫存器，需用n個觸發器來構成，
按照功能的不同，可將暫存器分為基本暫存器和移位暫存器兩大類，基本暫存器只能并行送入資料，也只能并行輸出，移位暫存器中的資料可以在移位脈沖作用下依次逐位右移或左移，資料既可以并行輸 入、 并行輸出，也可以串行輸入、串行輸出，還可以并行輸入、串行輸出，或串行輸入、并行輸出，十分靈活，用途也很廣，
原子性：
原子性（atomicity）是2018年公布的計算機科學技術名詞，
指事務的不可分割性，一個事務的所有操作要么不間斷地全部被執行，要么一個也沒有執行，
人話：多個執行緒一起執行的時候，一個操作一旦開始，就不會被其他執行緒所干擾，
例：
在Java中，對基本資料型別的變數的讀取和賦值操作是原子性操作，即這些操作是不可被中斷，要么執行，要么不執行，
- X=10; //原子性（簡單的讀取、將數字賦值給變數）
- Y = x; //不是原子操作，變數之間的相互賦值
- X++; //不是原子操作，對變數進行計算操作
- X = x+1;
陳述句2實際包括兩個操作，它先要去讀取x的值，再將y值寫入，兩個操作分開是原子性的，合在一起就不是原子性的，
陳述句3、4:x++ x=x+1包括3個操作：讀取x的值，x+1，將x寫入
補充：創建一個物件的程序
1、在堆區分配物件需要的記憶體
分配的記憶體包括本類和父類的所有實體變數，但不包括任何靜態變數
2、對所有實體變數賦默認值
將方法區內對實體變數的定義拷貝一份到堆區，然后賦默認值
3、執行實體初始化代碼
初始化順序是先初始化父類再初始化子類，初始化時先執行實體代碼塊然后是構造方法
4、如果有類似于Child c = new Child()形式的c參考的話，在堆疊區定義Child型別參考變數c，然后將堆區物件的地址賦值給它
需要注意的是，每個子類物件持有父類物件的參考，可在內部通過super關鍵字來呼叫父類物件，但在外部不可訪問
總結：原子性
instance = new Singleton();為非原子性的
(1)在堆上開辟空間；(2)屬性初始化;(3)參考指向物件
可以通過 synchronized和Lock實作更大范圍的原子性，因為synchronized和Lock能夠保證任一時刻只有一個執行緒訪問該代碼塊，
補充：lock是一個介面 大致用法
@Override
public void run() {
// TODO Auto-generated method stub
lock.lock();
try {
Thread.sleep(1000);
System.out.println("goon");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
lock.unlock();
}
}
有序性
人話：
即程式執行的順序按照代碼的先后順序執行
java指令重排序
為了性能優化， 為了進一步提升計算機各方面能力
在硬體層面做了很多優化，如處理器優化和指令重排等，但是這些技術的引入就會導致有序性問題
編譯器和處理器會進行指令重排序
多潭訓編指令執行時, 考慮性能因素, 會導致執行亂序
指令重排只可能發生在毫無關系的指令之間, 如果指令之間存在依賴關系, 則不會重排
總結：有序性
所以
instance = new Singleton();的三個操作可能被重新排序
所以執行緒2在讀取資料的時候 執行緒1可能已經參考指向物件了 但是還沒有初始化資料
所以回傳的還是null
所以volatile具有禁止指令重排序的作用， 其具有有序性，
回頭看單例類
假設有兩個執行緒 A、B 同時呼叫 getInstance() 方法，他們會同時發現 instance == null ，于是同時對 Singleton.class 加鎖，此時 JVM 保證只有一個執行緒能夠加鎖成功（假設是執行緒 A），另外一個執行緒則會處于等待狀態（假設是執行緒 B），執行緒 A 會創建一個 Singleton 實體，之后釋放鎖，鎖釋放后，執行緒 B 被喚醒，執行緒 B 再次嘗試加鎖，此時是可以加鎖成功的，加鎖成功后，執行緒 B 檢查 instance == null 時會發現，已經創建過 Singleton 實體了，所以執行緒 B 不會再創建一個 Singleton 實體，
這個程序看上去是不是無懈可擊，沒有漏洞？
答案是否定的，問題就出在了new操作上，我們以為的new操作是這樣的：
1.分配一塊記憶體空間
2.在這塊記憶體空間上初始化Singleton實體物件
3.把這個物件的記憶體地址賦值給instance變數
但實際上由于指令重排，優化后的程序是這樣的：
1.分配一塊記憶體空間
2.把這快記憶體空間的記憶體地址賦值給instance變數
3.在這塊記憶體空間上初始化Singleton實體物件
那么這樣調換順序后會發生什么呢？
我們假設執行緒 A 先執行 getInstance() 方法，當執行完指令 2 時恰好發生了執行緒切換，切換到了執行緒 B 上；如果此時執行緒 B 也執行 getInstance() 方法，那么執行緒 B 在執行第一個判斷時會發現 instance != null ，所以直接回傳 instance，而此時的 instance 是沒有初始化過的，如果我們這個時候訪問 instance 的成員變數就可能觸發空指標例外，
volatile與synchronized區別
- 僅靠volatile不能保證執行緒的安全性，（原子性）
- volatile輕量級，只能修飾變數，synchronized重量級，還可修飾方法
- volatile只能保證資料的可見性，不能用來同步，因為多個執行緒并發訪問volatile修飾的變數不會阻塞，
- synchronized不僅保證可見性，而且還保證原子性，因為，只有獲得了鎖的執行緒才能進入臨界區，從而保證臨界區中的所有陳述句都全部執行，多個執行緒爭搶synchronized鎖物件時，會出現阻塞，
總結：volatile和synchronized
執行緒安全三大特性：可見性 原子性 有序性
synchronized: 具有原子性，有序性和可見性；
volatile：具有有序性和可見性
單例類中雙重加鎖的原因
synchronized保證了創建物件操作的原子性 即一次進入一個執行緒
volatile保證了變數instance的可見性 也就是所有的操作都能實時被讀取
而volatile禁止了instance = new Singleton（）；的指令重排序 讀取---->數值初始化---->參考物件
最后的補充：volatile和synchronized的有序性為什么不一樣
volatile禁止指令重排
synchronized不能禁止指令重排 卻保證了有序性
怎么回答：
- 為了進一步提升計算機各方面能力，在硬體層面做了很多優化，如處理器優化和指令重排等，但是這些技術的引入就會導致有序性問題，
- 我們也知道，最好的解決有序性問題的辦法，就是禁止處理器優化和指令重排，就像volatile中使用記憶體屏障一樣，
- 但是，雖然很多硬體都會為了優化做一些重排，但是在Java中，不管怎么排序，都不能影響單執行緒程式的執行結果，這就是as-if-serial語意，所有硬體優化的前提都是必須遵守as-if-serial語意，
- 再說下synchronized，他是Java提供的鎖，可以通過他對Java中的物件加鎖，并且他是一種排他的、可重入的鎖，
- 所以，當某個執行緒執行到一段被synchronized修飾的代碼之前，會先進行加鎖，執行完之后再進行解鎖，在加鎖之后，解鎖之前，其他執行緒是無法再次獲得鎖的，只有這條加鎖執行緒可以重復獲得該鎖，
- synchronized通過排他鎖的方式就保證了同一時間內，被synchronized修飾的代碼是單執行緒執行的，所以呢，這就滿足了as-if-serial語意的一個關鍵前提，那就是單執行緒，因為有as-if-serial語意保證，單執行緒的有序性就天然存在了，
最后的最后的補充：volatile和記憶體屏障
記憶體屏障，也稱記憶體柵欄，記憶體柵障，屏障指令等， 是一類同步屏障指令，是CPU或編譯器在對記憶體隨機訪問的操作中的一個同步點，使得此點之前的所有讀寫操作都執行后才可以開始執行此點之后的操作，
- 在每一個volatile寫操作前面插入一個StoreStore屏障，這確保了在進行volatile寫之前前面的所有普通的寫操作都已經重繪到了記憶體，
- 在每一個volatile寫操作后面插入一個StoreLoad屏障，這樣可以避免volatile寫操作與后面可能存在的volatile讀寫操作發生重排序，
- 在每一個volatile讀操作后面插入一個LoadLoad屏障，這樣可以避免volatile讀操作和后面普通的讀操作進行重排序，
- 在每一個volatile讀操作后面插入一個LoadStore屏障，這樣可以避免volatile讀操作和后面普通的寫操作進行重排序，
參考文章
https://baike.baidu.com/item/volatile/10606957?fr=aladdin
https://zhuanlan.zhihu.com/p/138819184
https://baike.baidu.com/item/%E5%8E%9F%E5%AD%90%E6%80%A7/7760668?fr=aladdin
https://blog.csdn.net/tpriwwq/article/details/102484781
https://www.cnblogs.com/czwbig/p/11127124.html
https://www.jianshu.com/p/cf57726e77f2
https://www.cnblogs.com/xdecode/p/8948277.html
https://blog.csdn.net/a347911/article/details/88379625
https://blog.csdn.net/qq_37335220/article/details/89597489
https://blog.csdn.net/onroad0612/article/details/81382032
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/283170.html
標籤：其他
上一篇：百度云直鏈下載-IDM（一）