以下內(nèi)容轉(zhuǎn)自http://ifeve.com/locks/：

鎖像synchronized同步塊一樣，是一種線程同步機(jī)制，但比Java中的synchronized同步塊更復(fù)雜。因?yàn)殒i（以及其它更高級(jí)的線程同步機(jī)制）是由synchronized同步塊的方式實(shí)現(xiàn)的，所以我們還不能完全擺脫synchronized關(guān)鍵字（譯者注：這說的是Java 5之前的情況）。

自Java 5開始，java.util.concurrent.locks包中包含了一些鎖的實(shí)現(xiàn)，因此你不用去實(shí)現(xiàn)自己的鎖了。但是你仍然需要去了解怎樣使用這些鎖，且了解這些實(shí)現(xiàn)背后的理論也是很有用處的。可以參考我對(duì)java.util.concurrent.locks.Lock的介紹，以了解更多關(guān)于鎖的信息。

以下是本文所涵蓋的主題：

一個(gè)簡(jiǎn)單的鎖

讓我們從java中的一個(gè)同步塊開始：

public class Counter{private int count = 0;public int inc(){synchronized(this){return ++count;}} }

可以看到在inc()方法中有一個(gè)synchronized(this)代碼塊。該代碼塊可以保證在同一時(shí)間只有一個(gè)線程可以執(zhí)行return ++count。雖然在synchronized的同步塊中的代碼可以更加復(fù)雜，但是++count這種簡(jiǎn)單的操作已經(jīng)足以表達(dá)出線程同步的意思。

以下的Counter類用Lock代替synchronized達(dá)到了同樣的目的：

public class Counter{private Lock lock = new Lock();private int count = 0;public int inc(){lock.lock();int newCount = ++count;lock.unlock();return newCount;} }

lock()方法會(huì)對(duì)Lock實(shí)例對(duì)象進(jìn)行加鎖，因此所有對(duì)該對(duì)象調(diào)用lock()方法的線程都會(huì)被阻塞，直到該Lock對(duì)象的unlock()方法被調(diào)用。

這里有一個(gè)Lock類的簡(jiǎn)單實(shí)現(xiàn)：

public class Lock{private boolean isLocked = false;public synchronized void lock() throws InterruptedException{while(isLocked){wait();}isLocked = true;}public synchronized void unlock(){isLocked = false;notify();} }

注意其中的while(isLocked)循環(huán)，它又被叫做“自旋鎖”。自旋鎖以及wait()和notify()方法在線程通信這篇文章中有更加詳細(xì)的介紹。當(dāng)isLocked為true時(shí)，調(diào)用lock()的線程在wait()調(diào)用上阻塞等待。為防止該線程沒有收到notify()調(diào)用也從wait()中返回（也稱作虛假喚醒），這個(gè)線程會(huì)重新去檢查isLocked條件以決定當(dāng)前是否可以安全地繼續(xù)執(zhí)行還是需要重新保持等待，而不是認(rèn)為線程被喚醒了就可以安全地繼續(xù)執(zhí)行了。如果isLocked為false，當(dāng)前線程會(huì)退出while(isLocked)循環(huán)，并將isLocked設(shè)回true，讓其它正在調(diào)用lock()方法的線程能夠在Lock實(shí)例上加鎖。

當(dāng)線程完成了臨界區(qū)（位于lock()和unlock()之間）中的代碼，就會(huì)調(diào)用unlock()。執(zhí)行unlock()會(huì)重新將isLocked設(shè)置為false，并且通知（喚醒）其中一個(gè)（若有的話）在lock()方法中調(diào)用了wait()函數(shù)而處于等待狀態(tài)的線程。

鎖的可重入性

Java中的synchronized同步塊是可重入的。這意味著如果一個(gè)java線程進(jìn)入了代碼中的synchronized同步塊，并因此獲得了該同步塊使用的同步對(duì)象對(duì)應(yīng)的管程上的鎖，那么這個(gè)線程可以進(jìn)入由同一個(gè)管程對(duì)象所同步的另一個(gè)java代碼塊。下面是一個(gè)例子：

public class Reentrant{public synchronized outer(){inner();}public synchronized inner(){//do something } }

注意outer()和inner()都被聲明為synchronized，這在Java中和synchronized(this)塊等效。如果一個(gè)線程調(diào)用了outer()，在outer()里調(diào)用inner()就沒有什么問題，因?yàn)檫@兩個(gè)方法（代碼塊）都由同一個(gè)管程對(duì)象（”this”）所同步。如果一個(gè)線程已經(jīng)擁有了一個(gè)管程對(duì)象上的鎖，那么它就有權(quán)訪問被這個(gè)管程對(duì)象同步的所有代碼塊。這就是可重入。線程可以進(jìn)入任何一個(gè)它已經(jīng)擁有的鎖所同步著的代碼塊。

前面給出的鎖實(shí)現(xiàn)不是可重入的。如果我們像下面這樣重寫Reentrant類，當(dāng)線程調(diào)用outer()時(shí)，會(huì)在inner()方法的lock.lock()處阻塞住。

public class Reentrant2{Lock lock = new Lock();public outer(){lock.lock();inner();lock.unlock();}public synchronized inner(){lock.lock();//do something lock.unlock();} }

調(diào)用outer()的線程首先會(huì)鎖住Lock實(shí)例，然后繼續(xù)調(diào)用inner()。inner()方法中該線程將再一次嘗試鎖住Lock實(shí)例，結(jié)果該動(dòng)作會(huì)失敗（也就是說該線程會(huì)被阻塞），因?yàn)檫@個(gè)Lock實(shí)例已經(jīng)在outer()方法中被鎖住了。

兩次lock()之間沒有調(diào)用unlock()，第二次調(diào)用lock就會(huì)阻塞，看過lock()實(shí)現(xiàn)后，會(huì)發(fā)現(xiàn)原因很明顯：

public class Lock{boolean isLocked = false;public synchronized void lock() throws InterruptedException{while(isLocked){wait();}isLocked = true;}... }

一個(gè)線程是否被允許退出lock()方法是由while循環(huán)（自旋鎖）中的條件決定的。當(dāng)前的判斷條件是只有當(dāng)isLocked為false時(shí)lock操作才被允許，而沒有考慮是哪個(gè)線程鎖住了它。

為了讓這個(gè)Lock類具有可重入性，我們需要對(duì)它做一點(diǎn)小的改動(dòng)：

public class Lock{boolean isLocked = false;Thread lockedBy = null;int lockedCount = 0;public synchronized void lock() throws InterruptedException{Thread callingThread = Thread.currentThread();while(isLocked && lockedBy != callingThread){wait();}isLocked = true;lockedCount++;lockedBy = callingThread;}public synchronized void unlock(){if(Thread.curentThread() == this.lockedBy){lockedCount--;if(lockedCount == 0){isLocked = false;notify();}}}... }

注意到現(xiàn)在的while循環(huán)（自旋鎖）也考慮到了已鎖住該Lock實(shí)例的線程。如果當(dāng)前的鎖對(duì)象沒有被加鎖（isLocked = false），或者當(dāng)前調(diào)用線程已經(jīng)對(duì)該Lock實(shí)例加了鎖，那么while循環(huán)就不會(huì)被執(zhí)行，調(diào)用lock()的線程就可以退出該方法（譯者注：“被允許退出該方法”在當(dāng)前語(yǔ)義下就是指不會(huì)調(diào)用wait()而導(dǎo)致阻塞）。

除此之外，我們需要記錄同一個(gè)線程重復(fù)對(duì)一個(gè)鎖對(duì)象加鎖的次數(shù)。否則，一次unblock()調(diào)用就會(huì)解除整個(gè)鎖，即使當(dāng)前鎖已經(jīng)被加鎖過多次。在unlock()調(diào)用沒有達(dá)到對(duì)應(yīng)lock()調(diào)用的次數(shù)之前，我們不希望鎖被解除。

現(xiàn)在這個(gè)Lock類就是可重入的了。

鎖的公平性

Java的synchronized塊并不保證嘗試進(jìn)入它們的線程的順序。因此，如果多個(gè)線程不斷競(jìng)爭(zhēng)訪問相同的synchronized同步塊，就存在一種風(fēng)險(xiǎn)，其中一個(gè)或多個(gè)線程永遠(yuǎn)也得不到訪問權(quán)-也就是說訪問權(quán)總是分配給了其它線程。這種情況被稱作線程饑餓。為了避免這種問題，鎖需要實(shí)現(xiàn)公平性。本文所展現(xiàn)的鎖在內(nèi)部是用synchronized同步塊實(shí)現(xiàn)的，因此它們也不保證公平性。饑餓和公平中有更多關(guān)于該內(nèi)容的討論。

在finally語(yǔ)句中調(diào)用unlock()

如果用Lock來保護(hù)臨界區(qū)，并且臨界區(qū)有可能會(huì)拋出異常，那么在finally語(yǔ)句中調(diào)用unlock()就顯得非常重要了。這樣可以保證這個(gè)鎖對(duì)象可以被解鎖以便其它線程能繼續(xù)對(duì)其加鎖。以下是一個(gè)示例：

lock.lock(); try{//do critical section code,//which may throw exception } finally {lock.unlock(); }

這個(gè)簡(jiǎn)單的結(jié)構(gòu)可以保證當(dāng)臨界區(qū)拋出異常時(shí)Lock對(duì)象可以被解鎖。如果不是在finally語(yǔ)句中調(diào)用的unlock()，當(dāng)臨界區(qū)拋出異常時(shí)，Lock對(duì)象將永遠(yuǎn)停留在被鎖住的狀態(tài)，這會(huì)導(dǎo)致其它所有在該Lock對(duì)象上調(diào)用lock()的線程一直阻塞。

?

==>如有問題，請(qǐng)聯(lián)系我：easonjim#163.com，或者下方發(fā)表評(píng)論。<==

總結(jié)

以上是生活随笔為你收集整理的21、Java并发性和多线程-Java中的锁的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。