Java有多少種鎖

本篇內容介紹了“Java有多少種鎖”的有關(guān)知識，在實(shí)際案例的操作過(guò)程中，不少人都會(huì )遇到這樣的困境，接下來(lái)就讓小編帶領(lǐng)大家學(xué)習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學(xué)有所成！

重入鎖

鎖作為并發(fā)共享數據，保證一致性的工具，在JAVA平臺有多種實(shí)現(如 synchronized(重量級) 和 ReentrantLock(輕量級)等等 )  。這些已經(jīng)寫(xiě)好提供的鎖為我們開(kāi)發(fā)提供了便利。

重入鎖，也叫做遞歸鎖，指的是同一線(xiàn)程 外層函數獲得鎖之后 ，內層遞歸函數仍然有獲取該鎖的代碼，但不受影響。

在JAVA環(huán)境下 ReentrantLock 和synchronized 都是 可重入鎖

public class Test implements Runnable {     public synchronized void get() {         System.out.println("name:" + Thread.currentThread().getName() + " get();");         set();     }     public synchronized void set() {         System.out.println("name:" + Thread.currentThread().getName() + " set();");     }     @Override     public void run() {         get();     }     public static void main(String[] args) {         Test ss = new Test();         new Thread(ss).start();         new Thread(ss).start();         new Thread(ss).start();         new Thread(ss).start();     } } public class Test02 extends Thread {     ReentrantLock lock = new ReentrantLock();     public void get() {         lock.lock();         System.out.println(Thread.currentThread().getId());         set();         lock.unlock();     }     public void set() {         lock.lock();         System.out.println(Thread.currentThread().getId());         lock.unlock();     }     @Override     public void run() {         get();     }     public static void main(String[] args) {         Test ss = new Test();         new Thread(ss).start();         new Thread(ss).start();         new Thread(ss).start();     } }

讀寫(xiě)鎖

相比Java中的鎖(Locks in  Java)里L(fēng)ock實(shí)現，讀寫(xiě)鎖更復雜一些。假設你的程序中涉及到對一些共享資源的讀和寫(xiě)操作，且寫(xiě)操作沒(méi)有讀操作那么頻繁。在沒(méi)有寫(xiě)操作的時(shí)候，兩個(gè)線(xiàn)程同時(shí)讀一個(gè)資源沒(méi)有任何問(wèn)題，所以應該允許多個(gè)線(xiàn)程能在同時(shí)讀取共享資源。但是如果有一個(gè)線(xiàn)程想去寫(xiě)這些共享資源，就不應該再有其它線(xiàn)程對該資源進(jìn)行讀或寫(xiě)(譯者注：也就是說(shuō)：讀-讀能共存，讀-寫(xiě)不能共存，寫(xiě)-寫(xiě)不能共存)。這就需要一個(gè)讀/寫(xiě)鎖來(lái)解決這個(gè)問(wèn)題。Java5在java.util.concurrent包中已經(jīng)包含了讀寫(xiě)鎖。盡管如此，我們還是應該了解其實(shí)現背后的原理。

public class Cache {     static Map<String, Object> map = new HashMap<String, Object>();     static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();     static Lock r = rwl.readLock();     static Lock w = rwl.writeLock();     // 獲取一個(gè)key對應的value     public static final Object get(String key) {         r.lock();         try {             System.out.println("正在做讀的操作,key:" + key + " 開(kāi)始");             Thread.sleep(100);             Object object = map.get(key);             System.out.println("正在做讀的操作,key:" + key + " 結束");             System.out.println();             return object;         } catch (InterruptedException e) {         } finally {             r.unlock();         }         return key;     }     // 設置key對應的value，并返回舊有的value     public static final Object put(String key, Object value) {         w.lock();         try {             System.out.println("正在做寫(xiě)的操作,key:" + key + ",value:" + value + "開(kāi)始.");             Thread.sleep(100);             Object object = map.put(key, value);             System.out.println("正在做寫(xiě)的操作,key:" + key + ",value:" + value + "結束.");             System.out.println();             return object;         } catch (InterruptedException e) {         } finally {             w.unlock();         }         return value;     }     // 清空所有的內容     public static final void clear() {         w.lock();         try {             map.clear();         } finally {             w.unlock();         }     }     public static void main(String[] args) {         new Thread(new Runnable() {             @Override             public void run() {                 for (int i = 0; i < 10; i++) {                     Cache.put(i + "", i + "");                 }             }         }).start();         new Thread(new Runnable() {             @Override             public void run() {                 for (int i = 0; i < 10; i++) {                     Cache.get(i + "");                 }             }         }).start();     } }

悲觀(guān)鎖、樂(lè )觀(guān)鎖

樂(lè )觀(guān)鎖

總是認為不會(huì )產(chǎn)生并發(fā)問(wèn)題，每次去取數據的時(shí)候總認為不會(huì )有其他線(xiàn)程對數據進(jìn)行修改，因此不會(huì )上鎖，但是在更新時(shí)會(huì )判斷其他線(xiàn)程在這之前有沒(méi)有對數據進(jìn)行修改，一般會(huì )使用版本號機制或CAS操作實(shí)現。

version方式：一般是在數據表中加上一個(gè)數據版本號version字段，表示數據被修改的次數，當數據被修改時(shí)，version值會(huì )加一。當線(xiàn)程A要更新數據值時(shí)，在讀取數據的同時(shí)也會(huì )讀取version值，在提交更新時(shí)，若剛才讀取到的version值為當前數據庫中的version值相等時(shí)才更新，否則重試更新操作，直到更新成功。

核心SQL語(yǔ)句

update table set x=x+1, version=version+1 where id=#{id} and version=#{version};

CAS操作方式：即compare and swap 或者 compare and  set，涉及到三個(gè)操作數，數據所在的內存值，預期值，新值。當需要更新時(shí)，判斷當前內存值與之前取到的值是否相等，若相等，則用新值更新，若失敗則重試，一般情況下是一個(gè)自旋操作，即不斷的重試。

悲觀(guān)鎖

總是假設最壞的情況，每次取數據時(shí)都認為其他線(xiàn)程會(huì )修改，所以都會(huì )加鎖(讀鎖、寫(xiě)鎖、行鎖等)，當其他線(xiàn)程想要訪(fǎng)問(wèn)數據時(shí)，都需要阻塞掛起?？梢砸揽繑祿鞂?shí)現，如行鎖、讀鎖和寫(xiě)鎖等，都是在操作之前加鎖，在Java中，synchronized的思想也是悲觀(guān)鎖。

原子類(lèi)

java.util.concurrent.atomic包：原子類(lèi)的小工具包，支持在單個(gè)變量上解除鎖的線(xiàn)程安全編程

原子變量類(lèi)相當于一種泛化的 volatile 變量，能夠支持原子的和有條件的讀-改-寫(xiě)操作。AtomicInteger 表示一個(gè)int類(lèi)型的值，并提供了  get 和 set 方法，這些 Volatile 類(lèi)型的int變量在讀取和寫(xiě)入上有著(zhù)相同的內存語(yǔ)義。它還提供了一個(gè)原子的 compareAndSet  方法(如果該方法成功執行，那么將實(shí)現與讀取/寫(xiě)入一個(gè) volatile 變量相同的內存效果)，以及原子的添加、遞增和遞減等方法。AtomicInteger  表面上非常像一個(gè)擴展的 Counter 類(lèi)，但在發(fā)生競爭的情況下能提供更高的可伸縮性，因為它直接利用了硬件對并發(fā)的支持。

為什么會(huì )有原子類(lèi)

CAS：Compare and Swap，即比較再交換。

jdk5增加了并發(fā)包java.util.concurrent.*,其下面的類(lèi)使用CAS算法實(shí)現了區別于synchronouse同步鎖的一種樂(lè )觀(guān)鎖。JDK  5之前Java語(yǔ)言是靠synchronized關(guān)鍵字保證同步的，這是一種獨占鎖，也是是悲觀(guān)鎖。

如果同一個(gè)變量要被多個(gè)線(xiàn)程訪(fǎng)問(wèn)，則可以使用該包中的類(lèi)

AtomicBoolean

AtomicInteger

AtomicLong

AtomicReference

CAS無(wú)鎖模式

什么是CAS

CAS：Compare and Swap，即比較再交換。

jdk5增加了并發(fā)包java.util.concurrent.*,其下面的類(lèi)使用CAS算法實(shí)現了區別于synchronouse同步鎖的一種樂(lè )觀(guān)鎖。JDK  5之前Java語(yǔ)言是靠synchronized關(guān)鍵字保證同步的，這是一種獨占鎖，也是是悲觀(guān)鎖。

CAS算法理解

(1)與鎖相比，使用比較交換(下文簡(jiǎn)稱(chēng)CAS)會(huì )使程序看起來(lái)更加復雜一些。但由于其非阻塞性，它對死鎖問(wèn)題天生免疫，并且，線(xiàn)程間的相互影響也遠遠比基于鎖的方式要小。更為重要的是，使用無(wú)鎖的方式完全沒(méi)有鎖競爭帶來(lái)的系統開(kāi)銷(xiāo)，也沒(méi)有線(xiàn)程間頻繁調度帶來(lái)的開(kāi)銷(xiāo)，因此，它要比基于鎖的方式擁有更優(yōu)越的性能。

(2)無(wú)鎖的好處：

第一，在高并發(fā)的情況下，它比有鎖的程序擁有更好的性能;

第二，它天生就是死鎖免疫的。

就憑借這兩個(gè)優(yōu)勢，就值得我們冒險嘗試使用無(wú)鎖的并發(fā)。

(3)CAS算法的過(guò)程是這樣：它包含三個(gè)參數CAS(V,E,N):  V表示要更新的變量，E表示預期值，N表示新值。僅當V值等于E值時(shí)，才會(huì )將V的值設為N，如果V值和E值不同，則說(shuō)明已經(jīng)有其他線(xiàn)程做了更新，則當前線(xiàn)程什么都不做。最后，CAS返回當前V的真實(shí)值。

(4)CAS操作是抱著(zhù)樂(lè )觀(guān)的態(tài)度進(jìn)行的，它總是認為自己可以成功完成操作。當多個(gè)線(xiàn)程同時(shí)使用CAS操作一個(gè)變量時(shí)，只有一個(gè)會(huì )勝出，并成功更新，其余均會(huì )失敗。失敗的線(xiàn)程不會(huì )被掛起，僅是被告知失敗，并且允許再次嘗試，當然也允許失敗的線(xiàn)程放棄操作?；谶@樣的原理，CAS操作即使沒(méi)有鎖，也可以發(fā)現其他線(xiàn)程對當前線(xiàn)程的干擾，并進(jìn)行恰當的處理。

(5)簡(jiǎn)單地說(shuō)，CAS需要你額外給出一個(gè)期望值，也就是你認為這個(gè)變量現在應該是什么樣子的。如果變量不是你想象的那樣，那說(shuō)明它已經(jīng)被別人修改過(guò)了。你就重新讀取，再次嘗試修改就好了。

(6)在硬件層面，大部分的現代處理器都已經(jīng)支持原子化的CAS指令。在JDK  5.0以后，虛擬機便可以使用這個(gè)指令來(lái)實(shí)現并發(fā)操作和并發(fā)數據結構，并且，這種操作在虛擬機中可以說(shuō)是無(wú)處不在。

常用原子類(lèi)

Java中的原子操作類(lèi)大致可以分為4類(lèi)：原子更新基本類(lèi)型、原子更新數組類(lèi)型、原子更新引用類(lèi)型、原子更新屬性類(lèi)型。這些原子類(lèi)中都是用了無(wú)鎖的概念，有的地方直接使用CAS操作的線(xiàn)程安全的類(lèi)型。

AtomicBoolean

AtomicInteger

AtomicLong

AtomicReference

public class Test0001 implements Runnable {     private static Integer count = 1;     private static AtomicInteger atomic = new AtomicInteger();     @Override     public void run() {         while (true) {             int count = getCountAtomic();             System.out.println(count);             if (count >= 150) {                 break;             }         }     }     public synchronized Integer getCount() {         try {             Thread.sleep(50);         } catch (Exception e) {             // TODO: handle exception         }         return count++;     }     public Integer getCountAtomic() {         try {             Thread.sleep(50);         } catch (Exception e) {             // TODO: handle exception         }         return atomic.incrementAndGet();     }     public static void main(String[] args) {         Test0001 test0001 = new Test0001();         Thread t1 = new Thread(test0001);         Thread t2 = new Thread(test0001);         t1.start();         t2.start();     } }

CAS(樂(lè )觀(guān)鎖算法)的基本假設前提

CAS比較與交換的偽代碼可以表示為：

do{

備份舊數據;

基于舊數據構造新數據;

}while(!CAS( 內存地址，備份的舊數據，新數據 )

(上圖的解釋?zhuān)篊PU去更新一個(gè)值，但如果想改的值不再是原來(lái)的值，操作就失敗，因為很明顯，有其它操作先改變了這個(gè)值。)

就是指當兩者進(jìn)行比較時(shí)，如果相等，則證明共享數據沒(méi)有被修改，替換成新值，然后繼續往下運行;如果不相等，說(shuō)明共享數據已經(jīng)被修改，放棄已經(jīng)所做的操作，然后重新執行剛才的操作。容易看出  CAS 操作是基于共享數據不會(huì )被修改的假設，采用了類(lèi)似于數據庫的 commit-retry  的模式。當同步?jīng)_突出現的機會(huì )很少時(shí)，這種假設能帶來(lái)較大的性能提升。

public final int getAndAddInt(Object o, long offset, int delta) {  int v;  do {  v = getIntVolatile(o, offset);  } while (!compareAndSwapInt(o, offset, v, v + delta));  return v;  } /**       * Atomically increments by one the current value.       *       * @return the updated value       */      public final int incrementAndGet() {       for (;;) {       //獲取當前值       int current = get();       //設置期望值       int next = current + 1;       //調用Native方法compareAndSet，執行CAS操作       if (compareAndSet(current, next))       //成功后才會(huì )返回期望值，否則無(wú)線(xiàn)循環(huán)       return next;       }      }

CAS缺點(diǎn)

CAS存在一個(gè)很明顯的問(wèn)題，即ABA問(wèn)題。

問(wèn)題：如果變量V初次讀取的時(shí)候是A，并且在準備賦值的時(shí)候檢查到它仍然是A，那能說(shuō)明它的值沒(méi)有被其他線(xiàn)程修改過(guò)了嗎?

如果在這段期間曾經(jīng)被改成B，然后又改回A，那CAS操作就會(huì )誤認為它從來(lái)沒(méi)有被修改過(guò)。針對這種情況，java并發(fā)包中提供了一個(gè)帶有標記的原子引用類(lèi)AtomicStampedReference，它可以通過(guò)控制變量值的版本來(lái)保證CAS的正確性。

分布式鎖

如果想在不同的jvm中保證數據同步，使用分布式鎖技術(shù)。

有數據庫實(shí)現、緩存實(shí)現、Zookeeper分布式鎖