共享鎖（S鎖）

又稱為讀鎖，可以查看但無法修改和刪除的一種數據鎖。如果事務T對數據A加上共享鎖后，則其他事務只能對A再加共享鎖，不能加排它鎖。獲準共享鎖的事務只能讀數據，不能修改數據。 共享鎖下其它用戶可以并發讀取，查詢數據。但不能修改，增加，刪除數據。資源共享.

排它鎖（X鎖）

又稱為寫鎖、獨占鎖，若事務T對數據對象A加上X鎖，則只允許T讀取和修改A，其他任何事務都不能再對A加任何類型的鎖，直到T釋放A上的鎖。這就保證了其他事務在T釋放A上的鎖之前不能再讀取和修改A

互斥鎖

在編程中，引入了對象互斥鎖的概念，來保證共享數據操作的完整性。每個對象都對應于一個可稱為" 互斥鎖" 的標記，這個標記用來保證在任一時刻，只能有一個線程訪問該對象。

悲觀鎖

總是假設最壞的情況，每次去拿數據的時候都認為別人會修改，所以每次在拿數據的時候都會上鎖，這樣別人想拿這個數據就會阻塞直到它拿到鎖。傳統的關系型數據庫里邊就用到了很多這種鎖機制，比如行鎖，表鎖等，讀鎖，寫鎖等，都是在做操作之前先上鎖。再比如Java里面的同步原語synchronized關鍵字的實現也是悲觀鎖。

樂觀鎖

顧名思義，就是很樂觀，每次去拿數據的時候都認為別人不會修改，所以不會上鎖，但是在更新的時候會判斷一下在此期間別人有沒有去更新這個數據，可以使用版本號等機制。樂觀鎖適用于多讀的應用類型，這樣可以提高吞吐量，像數據庫提供的類似于write_condition機制，其實都是提供的樂觀鎖。在Java中java.util.concurrent.atomic包下面的原子變量類就是使用了樂觀鎖的一種實現方式CAS實現的。

行級鎖

行級鎖是 MySQL 中鎖定粒度最細的一種鎖，表示只針對當前操作的行進行加鎖。行級鎖能大大減少數據庫操作的沖突，其加鎖粒度最小，但加鎖的開銷也最大。行級鎖分為共享鎖和排他鎖。開銷大，加鎖慢；會出現死鎖；鎖定粒度最小，發生鎖沖突的概率最低，并發度也最高。

表級鎖

表級鎖是 MySQL 中鎖定粒度最大的一種鎖，表示對當前操作的整張表加鎖，它實現簡單，資源消耗較少，被大部分 MySQL 引擎支持。最常使用的 MyISAM 與 InnoDB 都支持表級鎖定。表級鎖定分為表共享讀鎖（共享鎖）與表獨占寫鎖（排他鎖）。開銷小，加鎖快；不會出現死鎖；鎖定粒度大，發出鎖沖突的概率最高，并發度最低。

頁級鎖

頁級鎖是 MySQL 中鎖定粒度介于行級鎖和表級鎖中間的一種鎖。表級鎖速度快，但沖突多，行級沖突少，但速度慢。因此，采取了折衷的頁級鎖，一次鎖定相鄰的一組記錄。BDB 支持頁級鎖。開銷和加鎖時間界于表鎖和行鎖之間；會出現死鎖；鎖定粒度界于表鎖和行鎖之間，并發度一般。

丟失修改

指事務1和事務2同時讀入相同的數據并進行修改，事務2提交的結果破壞了事務1提交的結果，導致事務1進行的修改丟失。

事務

不可重復讀

一個事務在讀取某些數據后的某個時間，再次讀取以前讀過的數據，卻發現其讀出的數據已經發生了改變、或某些記錄已經被刪除了！

讀臟數據

事務T1修改某一數據，并將其寫回磁盤，事務T2讀取同一數據后，T1由于某種原因被撤消，這時T1已修改過的數據恢復原值，T2讀到的數據就與數據庫中的數據不一致，則T2讀到的數據就為"臟"數據，即不正確的數據。

死鎖

兩個或兩個以上的進程在執行過程中，由于競爭資源或者由于彼此通信而造成的一種阻塞的現象，若無外力作用，它們都將無法推進下去。此時稱系統處于死鎖狀態或系統產生了死鎖，這些永遠在互相等待的進程稱為死鎖進程

死鎖四個產生條件

1）互斥條件

指進程對所分配到的資源進行排它性使用，即在一段時間內某資源只由一個進程占用。如果此時還有其它進程請求資源，則請求者只能等待，直至占有資源的進程用畢釋放。

2）請求和保持條件

指進程已經保持至少一個資源，但又提出了新的資源請求，而該資源已被其它進程占有，此時請求進程阻塞，但又對自己已獲得的其它資源保持不放。

3）不剝奪條件

指進程已獲得的資源，在未使用完之前，不能被剝奪，只能在使用完時由自己釋放。

4）環路等待條件

指在發生死鎖時，必然存在一個進程——資源的環形鏈，即進程集合{P0，P1，P2，···，Pn}中的P0正在等待一個P1占用的資源；P1正在等待P2占用的資源，……，Pn正在等待已被P0占用的資源。

預防死鎖打破上述之一的條件。

CAS

CAS(Compare and Swap 比較并交換)是樂觀鎖的一種實現方式

鎖存在的問題

Java在JDK1.5之前都是靠 synchronized關鍵字保證同步的，這種通過使用一致的鎖定協議來協調對共享狀態的訪問，可以確保無論哪個線程持有共享變量的鎖，都采用獨占的方式來訪問這些變量。這就是一種獨占鎖，獨占鎖其實就是一種悲觀鎖，所以可以說 synchronized 是悲觀鎖。

悲觀鎖機制存在以下問題

在多線程競爭下，加鎖、釋放鎖會導致比較多的上下文切換和調度延時，引起性能問題。

一個線程持有鎖會導致其它所有需要此鎖的線程掛起。

如果一個優先級高的線程等待一個優先級低的線程釋放鎖會導致優先級倒置，引起性能風險。

對比于悲觀鎖的這些問題，另一個更加有效的鎖就是樂觀鎖。其實樂觀鎖就是：每次不加鎖而是假設沒有并發沖突而去完成某項操作，如果因為并發沖突失敗就重試，直到成功為止。

樂觀鎖

其實就是一種思想。相對悲觀鎖而言，樂觀鎖假設認為數據一般情況下不會產生并發沖突，所以在數據進行提交更新的時候，才會正式對數據是否產生并發沖突進行檢測，如果發現并發沖突了，則返回用戶錯誤的信息，讓用戶決定如何去做。上面提到的樂觀鎖的概念中其實已經闡述了它的具體實現細節：主要就是兩個步驟：**沖突檢測和數據更新。**其實現方式有一種比較典型的就是 Compare and Swap ( CAS )。

CAS介紹

CAS是樂觀鎖技術，當多個線程嘗試使用CAS同時更新同一個變量時，只有其中一個線程能更新變量的值，而其它線程都失敗，失敗的線程并不會被掛起，而是被告知這次競爭中失敗，并可以再次嘗試。

CAS 操作中包含三個操作數 —— 需要讀寫的內存位置（V）、進行比較的預期原值（A）和擬寫入的新值(B)。如果內存位置V的值與預期原值A相匹配，那么處理器會自動將該位置值更新為新值B。否則處理器不做任何操作。無論哪種情況，它都會在 CAS 指令之前返回該位置的值。（在 CAS 的一些特殊情況下將僅返回 CAS 是否成功，而不提取當前值。）

CAS 有效地說明了“ 我認為位置 V 應該包含值 A；如果包含該值，則將 B 放到這個位置；否則，不要更改該位置，只告訴我這個位置現在的值即可。 ”這其實和樂觀鎖的沖突檢查+數據更新的原理是一樣的。

這里再強調一下，樂觀鎖是一種思想。CAS是這種思想的一種實現方式。

JAVA對CAS的支持

在JDK1.5 中新增 java.util.concurrent (J.U.C)就是建立在CAS之上的。相對于 synchronized 這種阻塞算法，CAS是非阻塞算法的一種常見實現。所以J.U.C在性能上有了很大的提升。

以 java.util.concurrent 中的 AtomicInteger 為例，看一下在不使用鎖的情況下是如何保證線程安全的。主要理解 getAndIncrement 方法，該方法的作用相當于 ++i 操作。

1 public class AtomicInteger extends Number implements java.io.Serializable { 2 private volatile int value; 3 4 public final int get() { 5 return value; 6 } 7 8 public final int getAndIncrement() { 9 for (;;) { 10 int current = get(); 11 int next = current + 1; 12 if (compareAndSet(current, next)) 13 return current; 14 } 15 } 16 17 public final boolean compareAndSet(int expect, int update) { 18 return unsafe.compareAndSwapInt(this, valueOffset, expect, update); 19 } 20 }

在沒有鎖的機制下,字段value要借助volatile原語，保證線程間的數據是可見性。這樣在獲取變量的值的時候才能直接讀取。然后來看看 ++i 是怎么做到的。

getAndIncrement 采用了CAS操作，每次從內存中讀取數據然后將此數據和 +1 后的結果進行CAS操作，如果成功就返回結果，否則重試直到成功為止。

而 compareAndSet 利用JNI（Java Native Interface）來完成CPU指令的操作：

1 public final boolean compareAndSet(int expect, int update) { 2 return unsafe.compareAndSwapInt(this, valueOffset, expect, update); 3 }　

其中unsafe.compareAndSwapInt(this, valueOffset, expect, update);類似如下邏輯：

1 if (this == expect) { 2 this = update 3 return true; 4 } else { 5 return false; 6 }

那么比較this == expect，替換this = update，compareAndSwapInt實現這兩個步驟的原子性呢？

CAS原理

CAS通過調用JNI的代碼實現的。而compareAndSwapInt就是借助C來調用CPU底層指令實現的。

下面從分析比較常用的CPU（intel x86）來解釋CAS的實現原理。

下面是sun.misc.Unsafe類的compareAndSwapInt()方法的源代碼：

1 public final native boolean compareAndSwapInt(Object o,long offset,int expected,int x);

可以看到這是個本地方法調用。這個本地方法在JDK中依次調用的C++代碼為：

1 #define LOCK_IF_MP(mp) __asm cmp mp, 0 \2 __asm je L0 \3 __asm _emit 0xF0 \4 __asm L0:5 6 inline jint Atomic::cmpxchg(jint exchange_value, volatile jint* dest, jint compare_value) {7 // alternative for InterlockedCompareExchange8 int mp = os::is_MP();9 __asm { 10 mov edx, dest 11 mov ecx, exchange_value 12 mov eax, compare_value 13 LOCK_IF_MP(mp) 14 cmpxchg dword ptr [edx], ecx 15 } 16 }

如上面源代碼所示，程序會根據當前處理器的類型來決定是否為cmpxchg指令添加lock前綴。如果程序是在多處理器上運行，就為cmpxchg指令加上lock前綴（lock cmpxchg）。反之，如果程序是在單處理器上運行，就省略lock前綴（單處理器自身會維護單處理器內的順序一致性，不需要lock前綴提供的內存屏障效果）。

CAS缺點

ABA問題

CAS看起來很爽，但是會導致“ABA問題”。

CAS算法實現一個重要前提需要取出內存中某時刻的數據，而在下時刻比較并替換，那么在這個時間差類會導致數據的變化。

比如說一個線程one從內存位置V中取出A，這時候另一個線程two也從內存中取出A，并且two進行了一些操作變成了B，然后two又將V位置的數據變成A，這時候線程one進行CAS操作發現內存中仍然是A，然后one操作成功。盡管線程one的CAS操作成功，但是不代表這個過程就是沒有問題的。如果鏈表的頭在變化了兩次后恢復了原值，但是不代表鏈表就沒有變化。因此前面提到的原子操作AtomicStampedReference/AtomicMarkableReference就很有用了。這允許一對變化的元素進行原子操作。

在運用CAS做Lock-Free操作中有一個經典的ABA問題：

線程1準備用CAS將變量的值由A替換為B，在此之前，線程2將變量的值由A替換為C，又由C替換為A，然后線程1執行CAS時發現變量的值仍然為A，所以CAS成功。但實際上這時的現場已經和最初不同了，盡管CAS成功，但可能存在潛藏的問題，例如下面的例子：

現有一個用單向鏈表實現的堆棧，棧頂為A，這時線程T1已經知道A.next為B，然后希望用CAS將棧頂替換為B：

head.compareAndSet(A,B);

在T1執行上面這條指令之前，線程T2介入，將A、B出棧，再pushD、C、A，此時堆棧結構如下圖，而對象B此時處于游離狀態：

此時輪到線程T1執行CAS操作，檢測發現棧頂仍為A，所以CAS成功，棧頂變為B，但實際上B.next為null，所以此時的情況變為：

其中堆棧中只有B一個元素，C和D組成的鏈表不再存在于堆棧中，平白無故就把C、D丟掉了。

以上就是由于ABA問題帶來的隱患，各種樂觀鎖的實現中通常都會用版本戳version來對記錄或對象標記，避免并發操作帶來的問題，在Java中，AtomicStampedReference也實現了這個作用，它通過包裝[E,Integer]的元組來對對象標記版本戳stamp，從而避免ABA問題，例如下面的代碼分別用AtomicInteger和AtomicStampedReference來對初始值為100的原子整型變量進行更新，AtomicInteger會成功執行CAS操作，而加上版本戳的AtomicStampedReference對于ABA問題會執行CAS失敗：

import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicStampedReference;public class ABA {private static AtomicInteger atomicInt = new AtomicInteger(100);private static AtomicStampedReference<Integer> atomicStampedRef = new AtomicStampedReference<Integer>(100, 0);public static void main(String[] args) throws InterruptedException {Thread intT1 = new Thread(new Runnable() {@Overridepublic void run() {atomicInt.compareAndSet(100, 101);atomicInt.compareAndSet(101, 100);}});Thread intT2 = new Thread(new Runnable() {@Overridepublic void run() {try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}boolean c3 = atomicInt.compareAndSet(100, 101);System.out.println(c3); //true}});intT1.start();intT2.start();intT1.join();intT2.join();Thread refT1 = new Thread(new Runnable() {@Overridepublic void run() {try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}atomicStampedRef.compareAndSet(100, 101, atomicStampedRef.getStamp(), atomicStampedRef.getStamp()+1);atomicStampedRef.compareAndSet(101, 100, atomicStampedRef.getStamp(), atomicStampedRef.getStamp()+1);}});Thread refT2 = new Thread(new Runnable() {@Overridepublic void run() {int stamp = atomicStampedRef.getStamp();System.out.println("before sleep : stamp = " + stamp); // stamp = 0try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("after sleep : stamp = " + atomicStampedRef.getStamp());//stamp = 1boolean c3 = atomicStampedRef.compareAndSet(100, 101, stamp, stamp+1);System.out.println(c3); //false}});refT1.start();refT2.start();}}

循環時間長開銷大

自旋CAS（不成功，就一直循環執行，直到成功）如果長時間不成功，會給CPU帶來非常大的執行開銷。如果JVM能支持處理器提供的pause指令那么效率會有一定的提升，pause指令有兩個作用，第一它可以延遲流水線執行指令（de-pipeline）,使CPU不會消耗過多的執行資源，延遲的時間取決于具體實現的版本，在一些處理器上延遲時間是零。第二它可以避免在退出循環的時候因內存順序沖突（memory order violation）而引起CPU流水線被清空（CPU pipeline flush），從而提高CPU的執行效率。

只能保證一個共享變量的原子操作

當對一個共享變量執行操作時，我們可以使用循環CAS的方式來保證原子操作，但是對多個共享變量操作時，循環CAS就無法保證操作的原子性，這個時候就可以用鎖，或者有一個取巧的辦法，就是把多個共享變量合并成一個共享變量來操作。比如有兩個共享變量i＝2,j=a，合并一下ij=2a，然后用CAS來操作ij。從Java1.5開始JDK提供了AtomicReference類來保證引用對象之間的原子性，你可以把多個變量放在一個對象里來進行CAS操作。

CAS與Synchronized的使用情景

1、對于資源競爭較少（線程沖突較輕）的情況，使用synchronized同步鎖進行線程阻塞和喚醒切換以及用戶態內核態間的切換操作額外浪費消耗cpu資源；而CAS基于硬件實現，不需要進入內核，不需要切換線程，操作自旋幾率較少，因此可以獲得更高的性能。

2、對于資源競爭嚴重（線程沖突嚴重）的情況，CAS自旋的概率會比較大，從而浪費更多的CPU資源，效率低于synchronized。

補充： synchronized在jdk1.6之后，已經改進優化。synchronized的底層實現主要依靠Lock-Free的隊列，基本思路是自旋后阻塞，競爭切換后繼續競爭鎖，稍微犧牲了公平性，但獲得了高吞吐量。在線程沖突較少的情況下，可以獲得和CAS類似的性能；而線程沖突嚴重的情況下，性能遠高于CAS。

concurrent包的實現

由于java的CAS同時具有 volatile 讀和volatile寫的內存語義，因此Java線程之間的通信現在有了下面四種方式：

1. A線程寫volatile變量，隨后B線程讀這個volatile變量。2. A線程寫volatile變量，隨后B線程用CAS更新這個volatile變量。3. A線程用CAS更新一個volatile變量，隨后B線程用CAS更新這個volatile變量。4. A線程用CAS更新一個volatile變量，隨后B線程讀這個volatile變量。　　　　

Java的CAS會使用現代處理器上提供的高效機器級別原子指令，這些原子指令以原子方式對內存執行讀-改-寫操作，這是在多處理器中實現同步的關鍵（從本質上來說，能夠支持原子性讀-改-寫指令的計算機器，是順序計算圖靈機的異步等價機器，因此任何現代的多處理器都會去支持某種能對內存執行原子性讀-改-寫操作的原子指令）。同時，volatile變量的讀/寫和CAS可以實現線程之間的通信。把這些特性整合在一起，就形成了整個concurrent包得以實現的基石。如果我們仔細分析concurrent包的源代碼實現，會發現一個通用化的實現模式：

1. 首先，聲明共享變量為volatile；　　2. 然后，使用CAS的原子條件更新來實現線程之間的同步；3. 同時，配合以volatile的讀/寫和CAS所具有的volatile讀和寫的內存語義來實現線程之間的通信。

AQS，非阻塞數據結構和原子變量類（java.util.concurrent.atomic包中的類），這些concurrent包中的基礎類都是使用這種模式來實現的，而concurrent包中的高層類又是依賴于這些基礎類來實現的。從整體來看，concurrent包的實現示意圖如下：

JVM中的CAS（堆中對象的分配）

Java調用new object()會創建一個對象，這個對象會被分配到JVM的堆中。那么這個對象到底是怎么在堆中保存的呢？

首先，new object()執行的時候，這個對象需要多大的空間，其實是已經確定的，因為java中的各種數據類型，占用多大的空間都是固定的（對其原理不清楚的請自行Google）。那么接下來的工作就是在堆中找出那么一塊空間用于存放這個對象。
在單線程的情況下，一般有兩種分配策略：

指針碰撞：這種一般適用于內存是絕對規整的（內存是否規整取決于內存回收策略），分配空間的工作只是將指針像空閑內存一側移動對象大小的距離即可。

空閑列表：這種適用于內存非規整的情況，這種情況下JVM會維護一個內存列表，記錄哪些內存區域是空閑的，大小是多少。給對象分配空間的時候去空閑列表里查詢到合適的區域然后進行分配即可。

但是JVM不可能一直在單線程狀態下運行，那樣效率太差了。由于再給一個對象分配內存的時候不是原子性的操作，至少需要以下幾步：查找空閑列表、分配內存、修改空閑列表等等，這是不安全的。解決并發時的安全問題也有兩種策略：

CAS：實際上虛擬機采用CAS配合上失敗重試的方式保證更新操作的原子性，原理和上面講的一樣。

TLAB：如果使用CAS其實對性能還是會有影響的，所以JVM又提出了一種更高級的優化策略：每個線程在Java堆中預先分配一小塊內存，稱為本地線程分配緩沖區（TLAB），線程內部需要分配內存時直接在TLAB上分配就行，避免了線程沖突。只有當緩沖區的內存用光需要重新分配內存的時候才會進行CAS操作分配更大的內存空間。
虛擬機是否使用TLAB，可以通過-XX:+/-UseTLAB參數來進行配置（jdk5及以后的版本默認是啟用TLAB的）。

總結

以上是生活随笔為你收集整理的详解各种锁：CAS、共享锁、排它锁、互斥锁、悲观锁、乐观锁、行级锁、表级锁、页级锁、死锁、JAVA对CAS的支持、ABA问题、AQS原理的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。