2. 程式人生 > >【轉載】Java併發程式設計：Lock

【轉載】Java併發程式設計：Lock

阿新 • • 發佈：2018-12-17

Java併發程式設計：Lock

　　在上一篇文章中我們講到了如何使用關鍵字synchronized來實現同步訪問。本文我們繼續來探討這個問題，從Java 5之後，在java.util.concurrent.locks包下提供了另外一種方式來實現同步訪問，那就是Lock。

　　也許有朋友會問，既然都可以通過synchronized來實現同步訪問了，那麼為什麼還需要提供Lock？這個問題將在下面進行闡述。本文先從synchronized的缺陷講起，然後再講述java.util.concurrent.locks包下常用的有哪些類和介面，最後討論以下一些關於鎖的概念方面的東西

　　以下是本文目錄大綱：

　　一.synchronized的缺陷

　　二.java.util.concurrent.locks包下常用的類

　　三.鎖的相關概念介紹

　　若有不正之處請多多諒解，並歡迎批評指正。

　　請尊重作者勞動成果，轉載請標明原文連結：

 　　http://www.cnblogs.com/dolphin0520/p/3923167.html

一.synchronized的缺陷

　　synchronized是java中的一個關鍵字，也就是說是Java語言內建的特性。那麼為什麼會出現Lock呢？

　　在上面一篇文章中，我們瞭解到如果一個程式碼塊被synchronized修飾了，當一個執行緒獲取了對應的鎖，並執行該程式碼塊時，其他執行緒便只能一直等待，等待獲取鎖的執行緒釋放鎖，而這裡獲取鎖的執行緒釋放鎖只會有兩種情況：

　　1）獲取鎖的執行緒執行完了該程式碼塊，然後執行緒釋放對鎖的佔有；

　　2）執行緒執行發生異常，此時JVM會讓執行緒自動釋放鎖。

　　那麼如果這個獲取鎖的執行緒由於要等待IO或者其他原因（比如呼叫sleep方法）被阻塞了，但是又沒有釋放鎖，其他執行緒便只能乾巴巴地等待，試想一下，這多麼影響程式執行效率。

　　因此就需要有一種機制可以不讓等待的執行緒一直無期限地等待下去（比如只等待一定的時間或者能夠響應中斷），通過Lock就可以辦到。

　　再舉個例子：當有多個執行緒讀寫檔案時，讀操作和寫操作會發生衝突現象，寫操作和寫操作會發生衝突現象，但是讀操作和讀操作不會發生衝突現象。

　　但是採用synchronized關鍵字來實現同步的話，就會導致一個問題：

　　如果多個執行緒都只是進行讀操作，所以當一個執行緒在進行讀操作時，其他執行緒只能等待無法進行讀操作。

　　因此就需要一種機制來使得多個執行緒都只是進行讀操作時，執行緒之間不會發生衝突，通過Lock就可以辦到。

　　另外，通過Lock可以知道執行緒有沒有成功獲取到鎖。這個是synchronized無法辦到的。

　　總結一下，也就是說Lock提供了比synchronized更多的功能。但是要注意以下幾點：

　　1）Lock不是Java語言內建的，synchronized是Java語言的關鍵字，因此是內建特性。Lock是一個類，通過這個類可以實現同步訪問；

　　2）Lock和synchronized有一點非常大的不同，採用synchronized不需要使用者去手動釋放鎖，當synchronized方法或者synchronized程式碼塊執行完之後，系統會自動讓執行緒釋放對鎖的佔用；而Lock則必須要使用者去手動釋放鎖，如果沒有主動釋放鎖，就有可能導致出現死鎖現象。

二.java.util.concurrent.locks包下常用的類

　　下面我們就來探討一下java.util.concurrent.locks包中常用的類和介面。

　　1.Lock

　　首先要說明的就是Lock，通過檢視Lock的原始碼可知，Lock是一個介面：

?

1

2

3

4

5

6

7

8

public interface Lock {

void lock();

void lockInterruptibly() throws InterruptedException;

boolean tryLock();

boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

void unlock();

Condition newCondition();

}

 　　下面來逐個講述Lock介面中每個方法的使用，lock()、tryLock()、tryLock(long time, TimeUnit unit)和lockInterruptibly()是用來獲取鎖的。unLock()方法是用來釋放鎖的。newCondition()這個方法暫且不在此講述，會在後面的執行緒協作一文中講述。

　　在Lock中聲明瞭四個方法來獲取鎖，那麼這四個方法有何區別呢？

　　首先lock()方法是平常使用得最多的一個方法，就是用來獲取鎖。如果鎖已被其他執行緒獲取，則進行等待。

　　由於在前面講到如果採用Lock，必須主動去釋放鎖，並且在發生異常時，不會自動釋放鎖。因此一般來說，使用Lock必須在try{}catch{}塊中進行，並且將釋放鎖的操作放在finally塊中進行，以保證鎖一定被被釋放，防止死鎖的發生。通常使用Lock來進行同步的話，是以下面這種形式去使用的：

?

1

2

3

4

5

6

7

8

9

Lock lock = ...;

lock.lock();

try{

//處理任務

}catch(Exception ex){

}finally{

lock.unlock();   //釋放鎖

}

　　tryLock()方法是有返回值的，它表示用來嘗試獲取鎖，如果獲取成功，則返回true，如果獲取失敗（即鎖已被其他執行緒獲取），則返回false，也就說這個方法無論如何都會立即返回。在拿不到鎖時不會一直在那等待。

　　tryLock(long time, TimeUnit unit)方法和tryLock()方法是類似的，只不過區別在於這個方法在拿不到鎖時會等待一定的時間，在時間期限之內如果還拿不到鎖，就返回false。如果如果一開始拿到鎖或者在等待期間內拿到了鎖，則返回true。

　　所以，一般情況下通過tryLock來獲取鎖時是這樣使用的：

?

1

2

3

4

5

6

7

8

9

10

11

12

Lock lock = ...;

if(lock.tryLock()) {

try{

//處理任務

}catch(Exception ex){

}finally{

lock.unlock();   //釋放鎖

} 

}else {

//如果不能獲取鎖，則直接做其他事情

}

 　　lockInterruptibly()方法比較特殊，當通過這個方法去獲取鎖時，如果執行緒正在等待獲取鎖，則這個執行緒能夠響應中斷，即中斷執行緒的等待狀態。也就使說，當兩個執行緒同時通過lock.lockInterruptibly()想獲取某個鎖時，假若此時執行緒A獲取到了鎖，而執行緒B只有在等待，那麼對執行緒B呼叫threadB.interrupt()方法能夠中斷執行緒B的等待過程。

　　由於lockInterruptibly()的宣告中丟擲了異常，所以lock.lockInterruptibly()必須放在try塊中或者在呼叫lockInterruptibly()的方法外宣告丟擲InterruptedException。

　　因此lockInterruptibly()一般的使用形式如下：

?

1

2

3

4

5

6

7

8

9

public void method() throws InterruptedException {

lock.lockInterruptibly();

try {  

//.....

}

finally {

lock.unlock();

}  

}

　　注意，當一個執行緒獲取了鎖之後，是不會被interrupt()方法中斷的。因為本身在前面的文章中講過單獨呼叫interrupt()方法不能中斷正在執行過程中的執行緒，只能中斷阻塞過程中的執行緒。

　　因此當通過lockInterruptibly()方法獲取某個鎖時，如果不能獲取到，只有進行等待的情況下，是可以響應中斷的。

　　而用synchronized修飾的話，當一個執行緒處於等待某個鎖的狀態，是無法被中斷的，只有一直等待下去。

　　2.ReentrantLock

　　ReentrantLock，意思是“可重入鎖”，關於可重入鎖的概念在下一節講述。ReentrantLock是唯一實現了Lock介面的類，並且ReentrantLock提供了更多的方法。下面通過一些例項看具體看一下如何使用ReentrantLock。

　　例子1，lock()的正確使用方法

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

public class Test {

private ArrayList<Integer> arrayList = new ArrayList<Integer>();

public static void main(String[] args)  {

final Test test = new Test();

new Thread(){

public void run() {

test.insert(Thread.currentThread());

};

}.start();

new Thread(){

public void run() {

test.insert(Thread.currentThread());

};

}.start();

}  

public void insert(Thread thread) {

Lock lock = new ReentrantLock();    //注意這個地方

lock.lock();

try {

System.out.println(thread.getName()+"得到了鎖");

for(int i=0;i<5;i++) {

arrayList.add(i);

}

} catch (Exception e) {

// TODO: handle exception

}finally {

System.out.println(thread.getName()+"釋放了鎖");

lock.unlock();

}

}

}

 　　各位朋友先想一下這段程式碼的輸出結果是什麼？

Thread-0得到了鎖
Thread-1得到了鎖
Thread-0釋放了鎖
Thread-1釋放了鎖

View Code

　　也許有朋友會問，怎麼會輸出這個結果？第二個執行緒怎麼會在第一個執行緒釋放鎖之前得到了鎖？原因在於，在insert方法中的lock變數是區域性變數，每個執行緒執行該方法時都會儲存一個副本，那麼理所當然每個執行緒執行到lock.lock()處獲取的是不同的鎖，所以就不會發生衝突。

　　知道了原因改起來就比較容易了，只需要將lock宣告為類的屬性即可。

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

public class Test {

private ArrayList<Integer> arrayList = new ArrayList<Integer>();

private Lock lock = new ReentrantLock();    //注意這個地方

public static void main(String[] args)  {

final Test test = new Test();

new Thread(){

public void run() {

test.insert(Thread.currentThread());

};

}.start();

new Thread(){

public void run() {

test.insert(Thread.currentThread());

};

}.start();

}  

public void insert(Thread thread) {

lock.lock();

try {

System.out.println(thread.getName()+"得到了鎖");

for(int i=0;i<5;i++) {

arrayList.add(i);

}

} catch (Exception e) {

// TODO: handle exception

}finally {

System.out.println(thread.getName()+"釋放了鎖");

lock.unlock();

}

}

}

 　　這樣就是正確地使用Lock的方法了。

　　例子2，tryLock()的使用方法

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

public class Test {

private ArrayList<Integer> arrayList = new ArrayList<Integer>();

private Lock lock = new ReentrantLock();    //注意這個地方

public static void main(String[] args)  {

final Test test = new Test();

new Thread(){

public void run() {

test.insert(Thread.currentThread());

};

}.start();

new Thread(){

public void run() {

test.insert(Thread.currentThread());

};

}.start();

}  

public void insert(Thread thread) {

if(lock.tryLock()) {

try {

System.out.println(thread.getName()+"得到了鎖");

for(int i=0;i<5;i++) {

arrayList.add(i);

}

} catch (Exception e) {

// TODO: handle exception

}finally {

System.out.println(thread.getName()+"釋放了鎖");

lock.unlock();

}

} else {

System.out.println(thread.getName()+"獲取鎖失敗");

}

}

}

 　　輸出結果：

Thread-0得到了鎖
Thread-1獲取鎖失敗
Thread-0釋放了鎖

View Code

　　例子3，lockInterruptibly()響應中斷的使用方法：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

public class Test {

private Lock lock = new ReentrantLock();   

public static void main(String[] args)  {

Test test = new Test();

MyThread thread1 = new MyThread(test);

MyThread thread2 = new MyThread(test);

thread1.start();

thread2.start();

try {

Thread.sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

}

thread2.interrupt();

}  

public void insert(Thread thread) throws InterruptedException{

lock.lockInterruptibly();   //注意，如果需要正確中斷等待鎖的執行緒，必須將獲取鎖放在外面，然後將InterruptedException丟擲

try {  

System.out.println(thread.getName()+"得到了鎖");

long startTime = System.currentTimeMillis();

for(    ;     ;) {

if(System.currentTimeMillis() - startTime >= Integer.MAX_VALUE)

break;

//插入資料

}

}

finally {

System.out.println(Thread.currentThread().getName()+"執行finally");

lock.unlock();

System.out.println(thread.getName()+"釋放了鎖");

}  

}

}

class MyThread extends Thread {

private Test test = null;

public MyThread(Test test) {

this.test = test;

}

@Override

public void run() {

try {

test.insert(Thread.currentThread());

} catch (InterruptedException e) {

System.out.println(Thread.currentThread().getName()+"被中斷");

}

}

}

　　執行之後，發現thread2能夠被正確中斷。

　　3.ReadWriteLock

　　ReadWriteLock也是一個介面，在它裡面只定義了兩個方法：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

public interface ReadWriteLock {

/**

* Returns the lock used for reading.

*

* @return the lock used for reading.

*/

Lock readLock();

/**

* Returns the lock used for writing.

*

* @return the lock used for writing.

*/

Lock writeLock();

}

 　　一個用來獲取讀鎖，一個用來獲取寫鎖。也就是說將檔案的讀寫操作分開，分成2個鎖來分配給執行緒，從而使得多個執行緒可以同時進行讀操作。下面的ReentrantReadWriteLock實現了ReadWriteLock介面。

　　4.ReentrantReadWriteLock

　　ReentrantReadWriteLock裡面提供了很多豐富的方法，不過最主要的有兩個方法：readLock()和writeLock()用來獲取讀鎖和寫鎖。

　　下面通過幾個例子來看一下ReentrantReadWriteLock具體用法。

　　假如有多個執行緒要同時進行讀操作的話，先看一下synchronized達到的效果：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

public class Test {

private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

public static void main(String[] args)  {

final Test test = new Test();

new Thread(){

public void run() {

test.get(Thread.currentThread());

};

}.start();

new Thread(){

public void run() {

test.get(Thread.currentThread());

};

}.start();

}  

public synchronized void get(Thread thread) {

long start = System.currentTimeMillis();

while(System.currentTimeMillis() - start <= 1) {

System.out.println(thread.getName()+"正在進行讀操作");

}

System.out.println(thread.getName()+"讀操作完畢");

}

}

 　　這段程式的輸出結果會是，直到thread1執行完讀操作之後，才會列印thread2執行讀操作的資訊。

Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0讀操作完畢
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1讀操作完畢

View Code

　　而改成用讀寫鎖的話：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

public class Test {

private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

public static void main(String[] args)  {

final Test test = new Test();

new Thread(){

public void run() {

test.get(Thread.currentThread());

};

}.start();

new Thread(){

public void run() {

test.get(Thread.currentThread());

};

}.start();

}  

public void get(Thread thread) {

rwl.readLock().lock();

try {

long start = System.currentTimeMillis();

while(System.currentTimeMillis() - start <= 1) {

System.out.println(thread.getName()+"正在進行讀操作");

}

System.out.println(thread.getName()+"讀操作完畢");

} finally {

rwl.readLock().unlock();

}

}

}

 　　此時列印的結果為：

複製程式碼

Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-0讀操作完畢
Thread-1讀操作完畢

複製程式碼

View Code

　　說明thread1和thread2在同時進行讀操作。

　　這樣就大大提升了讀操作的效率。

　　不過要注意的是，如果有一個執行緒已經佔用了讀鎖，則此時其他執行緒如果要申請寫鎖，則申請寫鎖的執行緒會一直等待釋放讀鎖。

　　如果有一個執行緒已經佔用了寫鎖，則此時其他執行緒如果申請寫鎖或者讀鎖，則申請的執行緒會一直等待釋放寫鎖。

　　關於ReentrantReadWriteLock類中的其他方法感興趣的朋友可以自行查閱API文件。

　　5.Lock和synchronized的選擇

　　總結來說，Lock和synchronized有以下幾點不同：

　　1）Lock是一個介面，而synchronized是Java中的關鍵字，synchronized是內建的語言實現；

　　2）synchronized在發生異常時，會自動釋放執行緒佔有的鎖，因此不會導致死鎖現象發生；而Lock在發生異常時，如果沒有主動通過unLock()去釋放鎖，則很可能造成死鎖現象，因此使用Lock時需要在finally塊中釋放鎖；

　　3）Lock可以讓等待鎖的執行緒響應中斷，而synchronized卻不行，使用synchronized時，等待的執行緒會一直等待下去，不能夠響應中斷；

　　4）通過Lock可以知道有沒有成功獲取鎖，而synchronized卻無法辦到。

　　5）Lock可以提高多個執行緒進行讀操作的效率。

　　在效能上來說，如果競爭資源不激烈，兩者的效能是差不多的，而當競爭資源非常激烈時（即有大量執行緒同時競爭），此時Lock的效能要遠遠優於synchronized。所以說，在具體使用時要根據適當情況選擇。

三.鎖的相關概念介紹

　　在前面介紹了Lock的基本使用，這一節來介紹一下與鎖相關的幾個概念。

　　1.可重入鎖

　　如果鎖具備可重入性，則稱作為可重入鎖。像synchronized和ReentrantLock都是可重入鎖，可重入性在我看來實際上表明瞭鎖的分配機制：基於執行緒的分配，而不是基於方法呼叫的分配。舉個簡單的例子，當一個執行緒執行到某個synchronized方法時，比如說method1，而在method1中會呼叫另外一個synchronized方法method2，此時執行緒不必重新去申請鎖，而是可以直接執行方法method2。

　　看下面這段程式碼就明白了：

?

1

2

3

4

5

6

7

8

9

class MyClass {

public synchronized void method1() {

method2();

}

public synchronized void method2() {

}

}

 　　上述程式碼中的兩個方法method1和method2都用synchronized修飾了，假如某一時刻，執行緒A執行到了method1，此時執行緒A獲取了這個物件的鎖，而由於method2也是synchronized方法，假如synchronized不具備可重入性，此時執行緒A需要重新申請鎖。但是這就會造成一個問題，因為執行緒A已經持有了該物件的鎖，而又在申請獲取該物件的鎖，這樣就會執行緒A一直等待永遠不會獲取到的鎖。

　　而由於synchronized和Lock都具備可重入性，所以不會發生上述現象。

　　2.可中斷鎖

　　可中斷鎖：顧名思義，就是可以相應中斷的鎖。

　　在Java中，synchronized就不是可中斷鎖，而Lock是可中斷鎖。

　　如果某一執行緒A正在執行鎖中的程式碼，另一執行緒B正在等待獲取該鎖，可能由於等待時間過長，執行緒B不想等待了，想先處理其他事情，我們可以讓它中斷自己或者在別的執行緒中中斷它，這種就是可中斷鎖。

　　在前面演示lockInterruptibly()的用法時已經體現了Lock的可中斷性。

　　3.公平鎖

　　公平鎖即儘量以請求鎖的順序來獲取鎖。比如同是有多個執行緒在等待一個鎖，當這個鎖被釋放時，等待時間最久的執行緒（最先請求的執行緒）會獲得該所，這種就是公平鎖。

　　非公平鎖即無法保證鎖的獲取是按照請求鎖的順序進行的。這樣就可能導致某個或者一些執行緒永遠獲取不到鎖。

　　在Java中，synchronized就是非公平鎖，它無法保證等待的執行緒獲取鎖的順序。

　　而對於ReentrantLock和ReentrantReadWriteLock，它預設情況下是非公平鎖，但是可以設定為公平鎖。

　　看一下這2個類的原始碼就清楚了：

　　

　　在ReentrantLock中定義了2個靜態內部類，一個是NotFairSync，一個是FairSync，分別用來實現非公平鎖和公平鎖。

　　我們可以在建立ReentrantLock物件時，通過以下方式來設定鎖的公平性：

?

1

ReentrantLock lock = new ReentrantLock(true);

 　　如果引數為true表示為公平鎖，為fasle為非公平鎖。預設情況下，如果使用無參構造器，則是非公平鎖。

　　

　　另外在ReentrantLock類中定義了很多方法，比如：

　　isFair()        //判斷鎖是否是公平鎖

　　isLocked()    //判斷鎖是否被任何執行緒獲取了

　　isHeldByCurrentThread()   //判斷鎖是否被當前執行緒獲取了

　　hasQueuedThreads()   //判斷是否有執行緒在等待該鎖

　　在ReentrantReadWriteLock中也有類似的方法，同樣也可以設定為公平鎖和非公平鎖。不過要記住，ReentrantReadWriteLock並未實現Lock介面，它實現的是ReadWriteLock介面。

　　4.讀寫鎖

　　讀寫鎖將對一個資源（比如檔案）的訪問分成了2個鎖，一個讀鎖和一個寫鎖。

　　正因為有了讀寫鎖，才使得多個執行緒之間的讀操作不會發生衝突。

　　ReadWriteLock就是讀寫鎖，它是一個介面，ReentrantReadWriteLock實現了這個介面。

　　可以通過readLock()獲取讀鎖，通過writeLock()獲取寫鎖。

　　上面已經演示過了讀寫鎖的使用方法，在此不再贅述。

　　參考資料：

相關推薦

【轉載】Java併發程式設計：Lock

Java併發程式設計：Lock 　　在上一篇文章中我們講到了如何使用關鍵字synchronized來實現同步訪問。本文我們繼續來探討這個問題，從Java 5之後，在java.util.concurrent.locks包下提供了另外一種方式來實現同步訪問，那就是Lock。

【34】Java併發程式設計：併發容器之CopyOnWriteArrayList（轉載）

Java併發程式設計：併發容器之CopyOnWriteArrayList（轉載） 　　原文連結： 　　http://ifeve.com/java-copy-on-write/ 　　 　　Copy-On-Write簡稱COW，是一種用於程式設計中的優化策略。其基本思路是，從一開始大家都

【轉】Java併發程式設計：同步容器

　　為了方便編寫出執行緒安全的程式，Java裡面提供了一些執行緒安全類和併發工具，比如：同步容器、併發容器、阻塞佇列、Synchronizer(比如CountDownLatch)。今天我們就來討論下同步容器。   一、為什麼會出現同步容器？ 　　在Java的集合容器框架中，主要有四大類別：Li

【轉】Java併發程式設計：併發容器之ConcurrentHashMap

　　JDK5中添加了新的concurrent包，相對同步容器而言，併發容器通過一些機制改進了併發效能。因為同步容器將所有對容器狀態的訪問都序列化了，這樣保證了執行緒的安全性，所以這種方法的代價就是嚴重降低了併發性，當多個執行緒競爭容器時，吞吐量嚴重降低。因此Java5.0開始針對多執行緒併發訪問設計，提供了併

【轉】Java併發程式設計：volatile關鍵字解析

volatile這個關鍵字可能很多朋友都聽說過，或許也都用過。在Java 5之前，它是一個備受爭議的關鍵字，因為在程式中使用它往往會導致出人意料的結果。在Java 5之後，volatile關鍵字才得以重獲生機。 　　volatile關鍵字雖然從字面上理解起來比較簡單，但

【轉】Java併發程式設計：深入剖析ThreadLocal

　想必很多朋友對ThreadLocal並不陌生，今天我們就來一起探討下ThreadLocal的使用方法和實現原理。首先，本文先談一下對ThreadLocal的理解，然後根據ThreadLocal類的原始碼分析了其實現原理和使用需要注意的地方，最後給出了兩個應用場景。 　　以

【4】Java併發程式設計：多執行緒中的快取一致性和CAS

一、匯流排鎖定和快取一致性 基本概念 這是兩個作業系統層面的概念。隨著多核時代的到來，併發操作已經成了很正常的現象，作業系統必須要有一些機制和原語，以保證某些基本操作的原子性，比如處理器需要保證讀一個位元組或寫一個位元組是原子的，那麼它是如何實現的呢?有

【漫畫】JAVA併發程式設計 J.U.C Lock包之ReentrantLock互斥鎖

在如何解決原子性問題的最後，我們賣了個關子，互斥鎖不僅僅只有synchronized關鍵字，還可以用什麼來實現呢？ J.U.C包中還提供了一個叫做Locks的包，我好歹英語過了四級，聽名字我就能馬上大聲的說：Locks包必然也可以用作互斥！ # ReentrantLock 我們可以通過從具體到抽象的方法來揭開

【架構】Java併發程式設計 - 深入剖析執行緒池

前言 如果我們要使用執行緒的時候就去建立一個，這樣雖然非常簡便，但是就會有一個問題： 如果併發的執行緒數量很多，並且每個執行緒都是執行一個時間很短的任務就結束了，這樣頻繁建立執行緒就會大大降低系統的效率，因為頻繁建立執行緒和銷燬執行緒需要時間。 那麼有沒有一種辦法使得執行緒可以複用

Java併發程式設計：Lock

從Java 5之後，在java.util.concurrent.locks包下提供了另外一種方式來實現同步訪問，那就是Lock。 　　也許有朋友會問，既然都可以通過synchronized來實現同步訪問了，那麼為什麼還需要提供Lock？這個問題將在下面進行闡述。本文先從sy

【轉】Java併發程式設計筆記之CopyOnWriteArrayList原始碼分析

併發包中併發List只有CopyOnWriteArrayList這一個，CopyOnWriteArrayList是一個執行緒安全的ArrayList,對其進行修改操作和元素迭代操作都是在底層建立一個拷貝陣列（快照）上進行的，也就是寫時拷貝策略。 我們首先看一下CopyOnW

（2.1.27.11）Java併發程式設計：Lock之ReentrantReadWriteLock 讀寫分離獨享式重入鎖

我們在介紹AbstractQueuedSynchronizer的時候介紹過，AQS支援獨佔式同步狀態獲取/釋放、共享式同步狀態獲取/釋放兩種模式，對應的典型應用分別是ReentrantLock和Semaphore AQS還可以混合兩種模式使用，讀寫鎖Reent

（2.1.27.13）Java併發程式設計：Lock之CountDownLatch計數式獨享鎖

CountDownLatch是一種java.util.concurrent包下一個同步工具類，它允許一個或多個執行緒等待直到在其他執行緒中一組操作執行完成。 相對於前文的鎖，它主要實現了： 呼叫指定次release後，才會釋放鎖 一、使用 public st

（2.1.27.16）Java併發程式設計：Lock之ConcurrentHashMap

ConcurrentHashMap 和 HashMap 的底層實現都是 陣列+連結串列或紅黑樹 構成的。 HashMap 的原始碼分析見：Java集合框架——HashMap原始碼分析 ConcurrentHashMap 相比 HashMap 支援多執行緒下的操

【 專欄 】- Java併發程式設計實戰

其實我想要   一種美夢睡不著   一種心臟的狂跳   瓦解界線不被撂倒 奔跑 依靠   我心中最想要   看你看過的浪潮   陪你放肆地年少   ——林俊杰【偉大的渺小】 ------------

【 分類 】- java併發程式設計

其實我想要   一種美夢睡不著   一種心臟的狂跳   瓦解界線不被撂倒 奔跑 依靠   我心中最想要   看你看過的浪潮   陪你放肆地年少   ——林俊杰【偉大的渺小】 ------------

【 專欄 】- Java併發程式設計指南

Java併發程式設計指南 最近聽很多面試的小夥伴說，網上往往是一篇一篇的Java多執行緒的文章，除了書籍沒有什麼學習多執行緒的一系列文章。但是僅僅憑藉一兩篇文章很難對多執行緒有系統的學習，而且面試的時候多執行緒這方面的知識往往也是

【思考】Java併發程式設計

CountDownLatch CountDownLatch是一種簡單的同步模式，它讓一個執行緒可以等待一個或多個執行緒完成它們的工作從而避免對臨界資源併發訪問所引發的各種問題。 主要方法  public CountDownLatch(int count);  public voidcountDown();/

【轉載】高併發解決：常見併發同步案例分析

案例一:訂票系統案例，某航班只有一張機票，假定有1w個人開啟你的網站來訂票，問你如何解決併發問題(可擴充套件到任何高併發網站要考慮               的併發讀寫問題)    問題，1w個人來訪問，票沒出去前要保證大家都能看到有票，不可能一個人在看到票的時候別人就不能

Java併發程式設計：Lock(比synchronized更靈活的同步)

Lock 是 java.util.concurrent.locks 包下的介面，Lock  實現提供了比使用 synchronized 方法和語句可獲得的更廣泛的鎖定操作，它能以更優雅的方式處理執行緒同步問題，我們拿Java執行緒(二)中的一個例子簡單的實現一下和 s