Java 中的鎖（Locking）機制主要是為了解決多線程環境下，對共享資源并發訪問時的同步和互斥控制，以確保共享資源的安全訪問。

鎖的作用主要體現在以下幾個方面：

• 互斥訪問：確保在任何時刻，只有一個線程能夠訪問特定的資源或執行特定的代碼段。這防止了多個線程同時修改同一資源導致的數據不一致問題。
• 內存可見性：通過鎖的獲取和釋放，可以確保在鎖保護的代碼塊中對共享變量的修改對其他線程可見。這是因為 Java 內存模型（JMM）規定，對鎖的釋放會把修改過的共享變量從線程的工作內存刷新到主內存中，而獲取鎖時會從主內存中讀取最新的共享變量值。
• 保證原子性：鎖能夠保證在其保護的代碼塊內，一系列操作是不可分割的整體，即原子操作。這意味著在多線程環境下，這些操作不會被線程調度機制打斷，從而避免了數據的不完整修改。
• 同步：協調線程間的執行順序，使得某些操作在另一些操作完成之后再執行，保證程序的邏輯正確性。例如，一個線程在寫入數據之后，另一個線程才能讀取該數據，以確保讀取到的數據是最新的。

1.鎖策略

在 Java 中有很多鎖策略，用于對鎖進行分類和指導鎖的（具體）實現，這些鎖策略包括以下內容：

• 樂觀鎖：它基于一種樂觀的思想，即認為數據一般情況下不會造成沖突，所以不會立即加上鎖，而是在數據進行更新提交的時候再進行檢查。如果發生沖突，則返回錯誤信息，讓用戶決定如何去做。
• 悲觀鎖：它總是假設最壞的情況，每次去拿數據的時候都認為別人會修改，所以每次在拿數據的時候都會上鎖，這樣別人想拿這個數據就會阻塞直到它拿到鎖。
• 自旋鎖：如果持有鎖的線程能在很短時間內釋放鎖，那么那些等待競爭鎖的線程就不需要做內核態和用戶態之間的切換進入阻塞掛起狀態，它們只需要等一等（自旋就是空循環），等持有鎖的線程釋放鎖后即可立即獲取鎖，這樣就避免用戶線程和內核的切換的消耗。
• 可重入鎖（遞歸鎖）：指的是同一個線程外層函數獲得鎖之后，內層遞歸函數仍然能獲得該鎖的代碼。即，線程可以進入任何一個它已經擁有的鎖所同步著的代碼塊。
• 讀寫鎖：在讀寫場景中，讀操作可以并發進行，但寫操作需要互斥進行。通過讀寫鎖可以實現讀寫分離，提高系統的并發性能。
• 公平鎖/非公平鎖：公平鎖是指多個線程按照申請鎖的順序來獲取鎖，類似排隊打飯，先到先得。非公平鎖是指多個線程獲取鎖的順序并不是按照申請鎖的順序，有可能后申請的線程比先申請的線程優先獲取鎖。
• 共享鎖/獨占鎖：共享鎖允許多個線程同時讀取一個資源，而獨占鎖則只允許一個線程訪問資源。
• 輕量級鎖/重量級鎖：這些是 Java 在 JVM 層面對 synchronized 鎖的優化，以減少線程之間的競爭和提高程序的性能。
• 分段鎖：將一把鎖分成多段，允許不同的線程同時訪問不同的段，從而提高了并發訪問的性能。
• 同步鎖：Java 內建的一種同步機制，例如 synchronized，它可以修飾方法或代碼塊，用于保護共享資源的訪問。

2.鎖實現

在 Java 中也有一些具體的鎖實現，用于代碼層面的鎖操作以此來保證線程安全的，這些常見的鎖實現有以下幾個：

• synchronized：內置鎖（Monitor Lock），可以用于方法或代碼塊，提供互斥訪問。當一個線程進入 synchronized 方法或塊時，它會自動獲取對象的鎖，其他線程則需等待鎖釋放后才能進入。
• ReentrantLock：是一個重入鎖，是 java.util.concurrent.locks 包中的接口 Lock 的實現，提供了比 synchronized 更靈活的鎖操作，如嘗試獲取鎖、可中斷的獲取鎖、超時獲取鎖等。它也支持公平鎖和非公平鎖策略。
• ReentrantReadWriteLock（讀寫鎖）：也是 java.util.concurrent.locks 包中的一部分，允許同時有多個讀取者，但只允許一個寫入者。它分為讀鎖和寫鎖，讀鎖之間不互斥，讀鎖與寫鎖互斥，寫鎖之間也互斥，適用于讀多寫少的場景。
• StampedLock（Java 8 引入）：提供了三種鎖模式：讀鎖、寫鎖和樂觀讀鎖。相較于 ReentrantReadWriteLock，StampedLock 提供了更細粒度的控制，支持樂觀讀取操作，可以提高并發性能。

（1）synchronized 使用

synchronized 可以用來修飾普通方法、靜態方法和代碼塊。

修飾普通方法

public synchronized void method() {
    // .......
}

當 synchronized 修飾普通方法時，被修飾的方法被稱為同步方法，其作用范圍是整個方法，作用的對象是調用這個方法的對象。

修飾靜態方法

public static synchronized void staticMethod() {
    // .......
}

當 synchronized 修飾靜態的方法時，其作用的范圍是整個方法，作用對象是調用這個類的所有對象。

修飾代碼塊

為了減少鎖的粒度，我們可以選擇在一個方法中的某個部分使用 synchronized 來修飾（一段代碼塊），從而實現對一個方法中的部分代碼進行加鎖，實現代碼如下：

public void classMethod() throws InterruptedException {
    // 前置代碼...
    
    // 加鎖代碼
    synchronized (SynchronizedExample.class) {
        // ......
    }
    
    // 后置代碼...
}

以上代碼在執行時，被修飾的代碼塊稱為同步語句塊，其作用范圍是大括號“{}”括起來的代碼塊，作用的對象是調用這個代碼塊的對象。

（2）ReentrantLock 使用

ReentrantLock 基本使用：

// 1. 創建ReentrantLock對象
ReentrantLock lock = new ReentrantLock();
// 2.獲取鎖
lock.lock(); 
try {
    // 3.得到鎖，執行需要同步的代碼塊
} finally {
    // 4.釋放鎖
    lock.unlock(); 
}

進階使用：嘗試獲取鎖并設定超時時間（可選）：

ReentrantLock lock = new ReentrantLock();
 // 嘗試獲取鎖，等待2秒，超時返回false
boolean locked = lock.tryLock(2, TimeUnit.SECONDS);
if (locked) {
    try {
        // 執行需要同步的代碼塊
    } finally {
        lock.unlock();
    }
}

（3）ReentrantReadWriteLock 使用

ReentrantReadWriteLock 特點如下：

• 多個線程可以同時獲取讀鎖，實現讀共享的并發訪問。
• 寫鎖是排它的，一旦有一個線程獲取寫鎖，其他線程無法獲取讀鎖或寫鎖，直到寫鎖釋放。
• 讀鎖與讀鎖之間可以共存，但寫鎖與讀鎖和寫鎖之間是互斥的。

也就是說：讀讀不互斥、讀寫互斥、寫寫互斥。

ReentrantReadWriteLock 基礎使用如下：

// 創建 ReentrantReadWriteLock 對象
ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
// 創建讀鎖
ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
// 獲取讀鎖
readLock.lock(); 
try {
    // 讀取共享資源的操作
} finally {
    // 釋放讀鎖
    readLock.unlock(); 
}
// 創建寫鎖
ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
// 獲取寫鎖
writeLock.lock();
try {
    // 寫入共享資源的操作
} finally {
    // 釋放寫鎖
    writeLock.unlock(); 
}

（4）StampedLock 使用

StampedLock 有三種讀寫方法：

• readLock()：讀鎖，用于多線程并發讀取共享資源。
• writeLock()：寫鎖，用于獨占寫入共享資源。
• tryOptimisticRead()：讀樂觀鎖，用于在不阻塞其他線程的情況下嘗試讀取共享資源。

其中 readLock() 和 writeLock() 方法與 ReentrantReadWriteLock 的用法類似，而 tryOptimisticRead() 方法則是 StampedLock 引入的新方法，它用于非常短的讀操作，它是使用如下：

// 創建 StampedLock 實例
StampedLock lock = new StampedLock();
// 獲取樂觀讀鎖
long stamp = lock.tryOptimisticRead(); 
// 讀取共享變量
if (!lock.validate(stamp)) { // 檢查樂觀讀鎖是否有效
    stamp = lock.readLock(); // 如果樂觀讀鎖無效，則獲取悲觀讀鎖
    try {
        // 重新讀取共享變量
    } finally {
        lock.unlockRead(stamp); // 釋放悲觀讀鎖
    }
}

// 獲取悲觀讀鎖
long stamp = lock.readLock(); 
try {
    // 讀取共享變量
} finally {
    lock.unlockRead(stamp); // 釋放悲觀讀鎖
}

// 獲取寫鎖
long stamp = lock.writeLock(); 
try {
    // 寫入共享變量
} finally {
    lock.unlockWrite(stamp); // 釋放寫鎖
}

使用樂觀讀鎖的特性可以提高讀操作的并發性能，適用于讀多寫少的場景。如果樂觀讀鎖獲取后，在讀取共享變量前發生了寫入操作，則 validate 方法會返回 false，此時需要轉換為悲觀讀鎖或寫鎖重新訪問共享變量。