1、鎖
（1）各種鎖
==可重入鎖（遞回鎖）：廣義上的可重入鎖，并非單指ReentrantLock，指的是同一執行緒外層函式獲得鎖后，內層遞回函式仍然有獲得該鎖的代碼，但不鎖影響，
==公平鎖：加鎖前檢查是否有排隊等候的執行緒，優先排隊等待的執行緒，按排隊順序來，
==不公平鎖：加鎖時，不考慮排隊等候的執行緒，直接獲取鎖，獲取不到自動到隊尾等候，效率比公平鎖高，因為公平鎖維護了一個佇列，可插隊，
==讀寫鎖：ReadWriteLock\ReentrantReadWriteLock，在讀的地方使用讀鎖，在寫的地方使用寫鎖，多個讀鎖不互斥，讀鎖和寫鎖互斥，
==共享鎖和獨占鎖
獨占鎖，每次只能有一個執行緒持有鎖，避免了讀/讀沖突，某個只讀執行緒獲取鎖，其它讀執行緒只能等待，如ReentrantLock獨占方式實作的互斥鎖，
共享鎖，允許多個執行緒同時獲取鎖，并發訪問資源，如ReadWriteLock允許讀讀，AQS佇列等待執行緒鎖的獲取也是共享鎖，
（2）鎖的四個狀態：無鎖，重量級鎖，輕量級鎖，偏量鎖
重量級鎖：同一時間，有多個執行緒同時競爭鎖
依賴作業系統的Mutex Lock來實作，會進行用戶態和內核態的轉換，和行程的背景關系切換，使用系統的互斥量來實作鎖，效率低（synchronized效率低的原因）
輕量級鎖：存在兩個執行緒一前一后執行同步代碼塊時，不存在同時競爭鎖
適應的場合是執行緒交替執行同步塊的情況和沒有多執行緒競爭的情況，如果存在同一時間訪問同一鎖的情況，會到導致鎖膨脹為重量級鎖，多次依賴CAS原子指令來獲取輕量級鎖和釋放鎖，
偏量鎖：總是由同一執行緒多次訪問同一同步代碼塊時，此時是偏量鎖
執行緒訪問加鎖代碼時，會在物件頭中存盤當前執行緒的ID，后續這個執行緒進入和退出這段加鎖代碼時，就不需要再次加鎖和釋放鎖，只需要在置換ThreadID時進行一次CAS原子指令，會節省性能消耗，只有一個執行緒執行同步塊時偏量鎖能提高性能，
2、volatile
（1）CPU快取模型：解決CPU處理速度和記憶體處理速度不對等的問題
（2）記憶體：可以看作外存的高速快取，是硬碟資料用于解決硬碟訪問速度過慢的問題
（3）JMM記憶體模型：解決快取不一致性問題
抽象 執行緒和主記憶體之間的關系
==主存：共享記憶體，所有執行緒創建的實體物件都存放在主記憶體中
==本地記憶體：每個執行緒都有一個私有的本地記憶體來存盤共享變數的副本， 每個執行緒只能訪問自己的本地記憶體，無法訪問其它執行緒的本地記憶體，
==造成的問題，一個執行緒在主存中修改一個變數的值，另一個執行緒還在繼續使用副本中的變數的值，會造成資料不一致性問題，解決方法：volatile
（4）并發編程的三個特性：
==1、原子性：一次或多次操作，要么都執行，要么都不執行，
synchronized可以保證代碼片段的原子性，volatile不能保證
==2、可見性：一個執行緒對共享變數進行修改，另外的執行緒能立即可見修改后的最新值，
synchronized和volatile可以保證共享變數的可見性，
==3、有序性：代碼執行程序中的代碼執行順序，未必是撰寫代碼時的順序，可能造成指令重排，
volatile可以禁止指令重排，
（5）synchronized和volatile的區別
==1、synchronized和volatile是互補的存在，不是對立的存在
==2、volatile輕量級實作，性能比synchronized好
==3、volatile只能作用于變數，synchronized能作用于變數、方法、類
==4、volatile主要用于解決多執行緒間記憶體可見性問題，使對volatile變數的讀寫直接寫入主存，保證變數的可見性，
synchronized主要用于解決執行控制問題，能夠對修飾的代碼進行加鎖，阻止其它執行緒的訪問，保證執行緒間訪問資源的同步性，
==5、volatile不會造成執行緒阻塞，沒有鎖操作，synchronized會造成執行緒阻塞，會進行鎖操作，
==6、volatile、synchronized可以保證可見性，synchronized還可以保證原子性，
synchronized保證可見性的原理：創建一個記憶體屏障，記憶體屏障指令保證所有CPU操作結果都會直接刷到主存中，從而保證操作的記憶體可見性，同時，記憶體屏障也可以禁止指令重排，從而保證有序性，
volatile保證可見性原理：會創建一個記憶體屏障，使得記憶體屏障的指令不能重新排序，保證有序性，同時，本地執行緒中的volatile變數的值會立即寫入到主存中，并使其它執行緒共享的volatile變數無效化，其它執行緒必須重新從主存中讀取其變數值，
3、synchronized
(1)synchronized :解決多執行緒間訪問的資源的同步性，可以保證被修飾的方法或代碼塊在任意時刻只有一個執行緒執行，
(2)synchronized:重量級的鎖
(3)使用方式：（3種）
==1、修飾普通方法：作用于當前物件實體，加鎖，鎖的是當前實體物件
synchronized void method() {
//業務代碼
}
==2、修飾靜態方法：作用于當前類，加鎖，鎖的是當前的class類
進入同步代碼前要獲得當前class類的鎖，synchronized加到static靜態方法和synchronized(.class)代碼塊上，都是給class類上鎖，
synchronized static void method() {
//業務代碼
}
==3、修飾代碼塊：指定加鎖物件，對指定的物件|類加鎖
進入同步代碼前要獲得給定物件|類的鎖
synchronized(this|object)表示進入同步代碼塊前要獲得給定物件的鎖
synchronized(類.class)表示進入同步代碼塊前要獲得當前class的鎖
synchronized(this) {
//業務代碼
}
====盡量不要使用synchronized(String a)，因為字串常量池有快取功能
====一個執行緒A呼叫一個實體物件的非靜態synchronized方法，而執行緒B需要呼叫這個實體物件所屬類的靜態synchronized方法，是允許的，不會發生互斥現象，因為訪問靜態synchronized方法占用的鎖，鎖的是當前類，而非靜態synchronized方法占用的鎖，鎖的是當前的實體物件，
（4）synchronized的底層實作原理
=1、synchronized關鍵字底層原理屬于JVM層面
javap 可以查看類的相關位元組碼資訊
==【1】、synchronized同步代碼塊的實作
使用 monitorenter 和 monitorexit 指令
monitor是基于C++實作的，有ObjectMonitor實作，每個物件都有內置一個ObjectMonitor物件
wait/notify 也依賴于monitor物件，因此只有在同步代碼塊和方法種才能呼叫wait/notify方法，否則會拋出java.lang.IllegalMonitorStateException的例外
===== monitorenter指令： 指向同步代碼塊的開始位置
===== monitorexit指令：指向同步代碼塊的結束位置
1、當執行monitorenter指令時，執行緒會獲取物件監視器monitor的持有權
2、同時，會嘗試獲取物件的鎖，鎖計數器為0說明鎖可以被獲取，獲取后鎖計數器設為1
3、執行緒擁有物件鎖才能執行monitorexit指令釋放鎖，執行monitorexit指令后，鎖計數器設為0，表明鎖被釋放，其它執行緒可以嘗試獲取鎖
4、獲取物件鎖失敗，當前執行緒會一直阻塞等待，直到鎖被運行中的執行緒釋放
==【2】、synchronized修飾方法的實作
沒有使用monitorenter 和 monitorexit 指令
使用 ACC_SYNCHRONIZED標識
=====ACC_SYNCHRONIZED標識，指明了該方法是一個同步方法
JVM通過ACC_SYNCHRONIZED標識辨別一個方法是否為同步方法，從而執行相應的同步呼叫
=====如果是實體方法，JVM會通過該ACC_SYNCHRONIZED標識，嘗試獲取實體物件的鎖
=====如果是靜態方法，JVM會通過該ACC_SYNCHRONIZED標識，嘗試獲取當前類class的鎖
==【3】synchronized修飾同步代碼塊和方法本質：獲取物件監視器monitor
（5）構造方法可以使用synchronized關鍵字修飾嗎？
不能，因為構造方法本身就屬于執行緒安全的，不存在同步的構造方法一說，因為實體物件還沒實體，怎么會有競爭呢？
（6）synchronized為什么是非公平鎖？體現在哪里呢？
==[1] 當持有鎖的執行緒釋放鎖時，該執行緒會執行以下重要操作：
先將鎖的持有者owner屬性賦值為null;
喚醒等待鏈表中的一個執行緒，
在喚醒等待的執行緒期間（還沒喚醒），若有其它執行緒嘗試獲取鎖，可以馬上獲取到鎖，（不公平，可插隊）
==[2]當執行緒嘗試獲取鎖失敗，會進入阻塞，會將執行緒放入鏈表里邊，但喚醒的順序不確定，先進入鏈表不代表會先被喚醒，（不公平，沒順序）
（7）synchronized鎖升級的原理
==[1]程序： 偏量鎖——>輕量級鎖——>重量級鎖
一個執行緒第一次訪問同步代碼塊時，鎖物件的物件頭中有一個ThreadId欄位，第一次訪問時，ThreadId為空，jvm會讓其獲得偏量鎖，并將ThreadId設定為其執行緒id(依賴一次CAS原子指令)；
當執行緒再次進入這個同步代碼塊時，會先判斷ThreadId是否與執行緒id一致，一致則可以直接使用此物件（不用再獲取鎖、釋放鎖）；不一致則進行鎖升級，偏量鎖升級為輕量級鎖，通過鎖自旋（依賴多次CAS原子指令），回圈一定次數后來獲取鎖，獲取要使用的物件；
輕量級鎖自旋一定次數后還沒有獲取到使用的物件，就會進行鎖升級，輕量級鎖升級為重量級鎖（依賴作業系統的Metux Lock），來獲取鎖和要獲取的物件；
這些程序構成了synchronized鎖的升級，
==[2]目的：鎖升級是為了減低鎖帶來的性能消耗，
Java6后優化synchronized的實作方式，使用了這種鎖升級的方式，減低了鎖帶來的性能消耗，
（8）JVM對 synchronized 的優化
==[1]新增了鎖的狀態：鎖消除、鎖粗化、自旋鎖
==[2]鎖膨脹（升級）：實際中到一定情況下會進行升級
=====膨脹（升級）方向：無鎖--->偏量鎖--->輕量級鎖--->重量級鎖
=====膨脹不可逆 膨脹的方向不能逆向
=====膨脹原理：有一個執行緒多次執行同一同步代碼塊時，此時，便是偏量鎖；當存在兩個執行緒一前一后執行同一同步代碼塊時，不存在同時競爭鎖的情況下，此時便是輕量級鎖；（期間，ThreadId存在不同，便會進行鎖升級，偏量級鎖升級為輕量級鎖）；當存在多個執行緒同時競爭鎖物件，同時要執行同一同步代碼塊時，便是重量級鎖，（期間，存在多執行緒競爭，輕量級鎖升級為重量級鎖）
==[3]鎖膨脹：優化更徹底，去除不可能存在競爭的鎖
優化前：synchronized(object){}
優化后：直接去掉該synchronized(){}
原因：因為object鎖是私有變數，不存在競爭關系
==[4]鎖粗化：更極端的優化處理，通過擴大鎖的范圍，避免反復加鎖和釋放鎖，
優化前：for(){synchronized(xxx.class){}}
優化后：synchronized(xxx.class){for(){}}
原因：避免反復加鎖解鎖，擴大鎖的范圍
==[5]自旋鎖：輕量級鎖切換執行緒時，執行緒執行回圈一定次數等待鎖的釋放，不讓出CPU，缺點：一直沒獲取鎖，一直不釋放CPU，會帶來性能開銷
==[6]自適應自旋鎖：自旋鎖的優化，自旋次數不再固定，自旋次數由前一次在同一鎖上的自旋時間及鎖的擁有者的狀態來決定，
（9）synchronized鎖能降級嗎？（降為無鎖狀態）
可以！！！但要具體的觸發時機
==[1]觸發時機：在全域安全點（sagepoint），執行清理任務時會觸發嘗試降級鎖，
==[2]降級鎖的操作：1、恢復鎖物件的markword物件頭
2、重置ObjectMonitor，將ObjectMonitor放入全域空閑串列，等待后續使用，
4、單例模式與volatile、synchronized
(1)餓漢式單例（使用前創建物件，反射可以破壞單例）
//餓漢式 單例
public class aHungry {
// 在使用時就已經存在 可能會浪費空間
private byte[] data1 = new byte[1024*1024];
private byte[] data2 = new byte[1024*1024];
private byte[] data3 = new byte[1024*1024];
private byte[] data4 = new byte[1024*1024];
//構造器私有
private aHungry(){}
private final static aHungry hungry = new aHungry();// 直接加載物件
public static aHungry getInstance(){
return hungry;
}
}
(2)懶漢式單例（使用時才進行物件創建）
//懶漢式單例
public class bLazyMan {
private bLazyMan() { System.out.println(Thread.currentThread().getName()+"==> ok");
}
private static bLazyMan bLazyMan;
public static bLazyMan getInstance(){
//沒加鎖 當要使用時才創建物件
if (bLazyMan==null){
bLazyMan = new bLazyMan();
}
return bLazyMan;
}
public static void main(String[] args) {
// bLazyMan.getInstance(); // 單執行緒下 單例
// 多執行緒并發下 懶漢式單例 會有問題 可能有一個或多個執行緒 因此可以加鎖 -->雙重檢測鎖模式懶漢式 DCL懶漢式
for (int i = 0; i < 10; i++) {
new Thread(() -> {
bLazyMan.getInstance();
}).start();
}
}
}
(3)雙重檢驗鎖懶漢式單例 DCL懶漢式
//雙重檢驗鎖
public class CLockLazyMan {
private CLockLazyMan() { System.out.println(Thread.currentThread().getName()+"==> ok");
}
private volatile static CLockLazyMan cLockLazyMan;
public static CLockLazyMan getInstance(){
//先判斷物件是否已經實體過，沒有實體過才進入加鎖代碼
if (cLockLazyMan==null){
//對類物件進行加鎖
synchronized (cLockLazyMan.class){
if (cLockLazyMan==null){
cLockLazyMan = new CLockLazyMan(); //不是原子性操作
/* 正確的指令順序
1 分配記憶體空間
2 執行構造方法 初始化物件
3 把這個物件指向記憶體空間
但 可能會出現 指令重排 即指令重排 回傳cLockLazyMan還沒有初始化物件 因此還要加上volatile
*/
}
}
}
return cLockLazyMan;
}
public static void main(String[] args) {
// cLockLazyMan.getInstance(); // 單執行緒下 單例
// 雙重檢測鎖模式懶漢式 DCL懶漢式
for (int i = 0; i < 10; i++) {
new Thread(() -> {
cLockLazyMan.getInstance();
}).start();
}
}
}
正確的指令順序
1 為cLockLazyMan分配記憶體空間
2 執行構造方法 初始化cLockLazyMan物件
3 把這個物件cLockLazyMan指向分配好的記憶體空間
但由于JVM具有指令重排的特性 可能會出現 指令重排 1->3->2
指令重排在單執行緒環境下不會出現問題，但多執行緒環境下可能會發生指令重排，會回傳cLockLazyMan還沒有初始化物件 ，執行緒1執行1、3后，執行緒2執行呼叫getInstance()時，會發現cLockLazyMan不為空，并回傳，但此時的cLockLazyMan還沒被初始化呢
因此要對變數cLockLazyMan加上volatile，禁止JVM的指令重排，保證多執行緒下的正常允許，
靜態內部類單例
//靜態內部類
public class cHolder {
private cHolder(){}
private static cHolder getInstance(){
return InnerClass.cHolder;
}
public static class InnerClass{
private static final cHolder cHolder = new cHolder();
}
}
列舉（列舉本身是單例） 列舉沒有無參構造，是有參構造（String,int）
if ((clazz.getModifiers() & Modifier.ENUM) != 0)
throw new IllegalArgumentException("Cannot reflectively create enum objects");
ConstructorAccessor ca = constructorAccessor; // read volatile
5、CAS(Compare And Swap) 比較并交換 操作CPU原語（不可分割，連續不中斷 即保證原子性）
（1）CAS:可以解決多執行緒并行下使用鎖造成性能損耗的一種機制，
（2）CAS運算元（3個）：記憶體位置（V）和預期原值（A）以及新值（B）
（3）原理：
==簡意：比較當前作業記憶體中的值和主記憶體中的值，如果這個值是期望的，就執行操作，如果不是就一直回圈，
==定義：
如果記憶體位置的值（V）與預期的值（A）相匹配，處理器會自動將該位置的值設定為新值（B）；
如果處理器不做任何操作，一個執行緒會從主記憶體中得到num值，并對num值進行操作，在寫入值時，執行緒會把第一次取到的num值和主存中的num值進行比較，如果相等，就會將改變后的num值寫入主記憶體中，如果不相等，就會一直回圈對比，直到成功為止，
（4）理解CAS
例：使用原子類AtomicInteger進行理解
public static void main(String[] args) {
//定義原子型別 定義為 2022
AtomicInteger atomicInteger = new AtomicInteger(2022);
// public final boolean compareAndSet(int expect, int update)
// 比較并更換 期望 更新 如果期望達到了就更新 否則不更新
System.out.println(atomicInteger.compareAndSet(2022, 2023)); //true
System.out.println(atomicInteger.get()); //2023 達到期望的2022 進行更換
//再次 比較更換
System.out.println(atomicInteger.compareAndSet(2022, 2023)); //false
System.out.println(atomicInteger.get()); //2023 但沒有更換成功
}
==AtomicInteger的原始碼,使用Unsafe類 native類，使用c++操作記憶體
==通過 原子類自增1的方法 理解CAS
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}
（4）CAS的產生：修飾共享變數時會使用volatile關鍵字，volatile保證可見性和有序性，但無法保證原子性（多執行緒下會造成不安全的現象），利用CAS可以利用CPU原語（不可分割，連續不中斷）保證現場操作的原子性，
（5）優缺點：
==優點：樂觀鎖的思想，非阻塞的輕量級鎖，即一個執行緒的失敗或掛起不影響其它執行緒的失敗或掛起的演算法，
==缺點：
====底層是自旋鎖，自旋回圈會產生消耗，回圈時間開銷大，占用CPU資源
==== 一次性只能保證一個共享變數的原子性操作，對于多個共享變數操作時，回圈CAS無法保證操作的原子性，
====可能會產生ABA問題（貍貓換太子）
例如：主存原A=1 執行緒1 CAS(1,2)，執行緒2 CAS(1,3)、CAS(3,1)
若執行緒2比執行緒1先執行，主存中A=1已經發生了改變了，但 執行緒1不知情（A=1已經不是原來的A=1了）
（6）解決問題
==1、解決自旋時間消耗開銷大的問題
====若JVM支持處理器的pause指令，就可以解決，
====pause指令的作用：[1]延遲流水線執行指令de-pipeline，使CPU不過多消耗執行資源，延遲時間取決于具體的實作版本，
[2]避免在退出回圈時因記憶體順序沖突而引起CPU流水線被清空，從而提高CPU的執行效率
==2、解決一次性只能保證一個共享變數的原子操作的問題
====方法一：可以使用鎖，不使用CAS了
====方法二：可以把多個共享變數合并成一個共享變數用CAS操作
AtomicReference類保證參考物件間的原子性，可以把多個變數放在一個物件里來進行CAS操作，
==3、解決ABA問題
===方法一：添加版本號（樂觀鎖原理）
===方法二：AtomicStampedReference類 參考原子類（方法一的實際操作）
使用AtomicStampedReference的compareAndSet()方法：首先檢查當前參考是否等于預期參考，并且當前標志是否等于預期標志，如果全部相等，則以原子方式將該參考和該標志的值設定為給定的更新值，
public AtomicStampedReference(V initialRef （期望）, int initialStamp（時間戳、版本）)
public boolean compareAndSet(V expectedReference,//預期值
V newReference,//新值
int expectedStmap,//預期戳記
int newStmap //新戳記
)
例：解決ABA問題
//解決ABA問題 原子參考 類似 樂觀鎖原理 有時間戳(版本號)
public class cCAStoABATest {
public static void main(String[] args) {
//如果泛型是包裝類 要注意物件的參考問題 范圍問題
//正常作業中 一般參考的是一個物件
AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<Integer>(4,1);
new Thread(()->{
//獲取當前時間戳 即版本號
int stamp = atomicStampedReference.getStamp();
System.out.println("a 1 ==> "+stamp);
?
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
//CAS操作
System.out.println("a 2"+atomicStampedReference.compareAndSet(4, 28, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
System.out.println("a 2 ==> "+atomicStampedReference.getStamp());
System.out.println("a 2"+atomicStampedReference.compareAndSet(28, 4, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
System.out.println("a 3 ==> "+atomicStampedReference.getStamp());
},"a").start();
new Thread(()->{
//獲取當前時間戳 即版本號
int stamp = atomicStampedReference.getStamp();
System.out.println("b 1 ==> "+stamp);
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
//stamp 不是原來的版本了 就會失敗
System.out.println("b 2"+atomicStampedReference.compareAndSet(4, 28, stamp, stamp + 1));
System.out.println("b 2 ==> "+atomicStampedReference.getStamp());
},"b").start();
}
}
（7）CAS使用時機：
==1、執行緒數較少、等待時間短，可以采用自旋鎖進行CAS
==2、執行緒數較大、等待時間長，不建議使用，占用CPU資源消耗高
6、Atomic原子類 （java.util.concurrent.atomic）juc包下
（1）原子：指一個操作時不可中斷的，即使是多執行緒的情況下，一個操作一旦開始，便不能被其它執行緒干擾，
（2）原子類：具有原子性\原子操作特征的類
（3）型別（4類）
基本型別：
===整型原子類：AtomicInteger
===長整型原子類：AtomicLong
===布爾型原子類：AtomicBoolean
陣列型別：
===參考型別原子類：AtomicReference
===原子更新帶版本號的參考型別：AtomicStampedReference
用于解決原子的更新資料和資料的版本號，解決CAS的ABA問題
===原子更新帶有標記位的參考型別：AtomicMarkableReference
物件的屬性修改型別：
===原子更新整型欄位的更新器：AtomicIntegerFieldUpdater
===原子更新長整型欄位的更新器：AtomicLongFieldUpdater
===原子更新參考型別欄位的更新器：AtomicReferenceFieldUpdater
（4）Atomic類的執行緒安全原理——AtomicInteger類為例
==1、原理分析
AtomicInteger原始碼：
// setup to use Unsafe.compareAndSwapInt for updates（更新操作時提供“比較并替換”的作用）
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;
?
static {
try {
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
?
private volatile int value;
AtomicInteger類主要利用CAS+volatile+native方法保證原子操作，避免了synchronized的高開銷，執行效率提升，
==CAS原理：期望值和原值進行比較，相同則更新，不同則自旋
==UnSafe.objectFieldOffset()方法是一個本地native方法：用于拿到原值的記憶體地址，回傳的是valueOffser
==value是一個volatile變數，使記憶體可見，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/458424.html
標籤：Java
上一篇：運算子(1)