可重入鎖詳解
概述
什麼是 “可重入”，可重入就是說某個線程已經獲得某個鎖，可以再次獲取鎖而不會出現死鎖。例如
package com.test.reen;
// 演示可重入鎖是什麼意思，可重入，就是可以重複獲取相同的鎖，synchronized和ReentrantLock都是可重入的
// 可重入降低了編程複雜性
public class WhatReentrant {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
synchronized (this) {
System.out.println("第1次獲取鎖，這個鎖是：" + this);
int index = 1;
while (true) {
synchronized (this) {
System.out.println("第" + (++index) + "次獲取鎖，這個鎖是：" + this);
}
if (index == 10) {
break;
}
}
}
}
}).start();
}
}
package com.test.reen;
import java.util.Random;
import java.util.concurrent.locks.ReentrantLock;
// 演示可重入鎖是什麼意思
public class WhatReentrant2 {
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
new Thread(new Runnable() {
@Override
public void run() {
try {
lock.lock();
System.out.println("第1次獲取鎖，這個鎖是：" + lock);
int index = 1;
while (true) {
try {
lock.lock();
System.out.println("第" + (++index) + "次獲取鎖，這個鎖是：" + lock);
try {
Thread.sleep(new Random().nextInt(200));
} catch (InterruptedException e) {
e.printStackTrace();
}
if (index == 10) {
break;
}
} finally {
lock.unlock();
}
}
} finally {
lock.unlock();
}
}
}).start();
}
}
可以發現沒發生死鎖，可以多次獲取相同的鎖
可重入鎖有
synchronized
ReentrantLock
使用ReentrantLock的注意點
ReentrantLock 和 synchronized 不一樣，需要手動釋放鎖，所以使用 ReentrantLock的時候一定要手動釋放鎖，並且加鎖次數和釋放次數要一樣
以下代碼演示，加鎖和釋放次數不一樣導致的死鎖
package com.test.reen;
import java.util.Random;
import java.util.concurrent.locks.ReentrantLock;
public class WhatReentrant3 {
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
new Thread(new Runnable() {
@Override
public void run() {
try {
lock.lock();
System.out.println("第1次獲取鎖，這個鎖是：" + lock);
int index = 1;
while (true) {
try {
lock.lock();
System.out.println("第" + (++index) + "次獲取鎖，這個鎖是：" + lock);
try {
Thread.sleep(new Random().nextInt(200));
} catch (InterruptedException e) {
e.printStackTrace();
}
if (index == 10) {
break;
}
} finally {
// lock.unlock();// 這裏故意註釋，實現加鎖次數和釋放次數不一樣
}
}
} finally {
lock.unlock();
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
try {
lock.lock();
for (int i = 0; i < 20; i++) {
System.out.println("threadName:" + Thread.currentThread().getName());
try {
Thread.sleep(new Random().nextInt(200));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} finally {
lock.unlock();
}
}
}).start();
}
}
由於加鎖次數和釋放次數不一樣，第二個線程始終無法獲取到鎖，導致一直在等待。
稍微改一下，在外層的finally裏頭釋放9次，讓加鎖和釋放次數一樣，就沒問題了
try {
lock.lock();
System.out.println("第1次獲取鎖，這個鎖是：" + lock);
int index = 1;
while (true) {
try {
lock.lock();
System.out.println("第" + (++index) + "次獲取鎖，這個鎖是：" + lock);
... 代碼省略節省篇幅...
} finally {
// lock.unlock();// 這裏故意註釋，實現加鎖次數和釋放次數不一樣
}
}
} finally {
lock.unlock();
// 在外層的finally裏頭釋放9次，讓加鎖和釋放次數一樣，就沒問題了
for (int i = 0; i < 9; i++) {
lock.unlock();
}
}
————————————————
版權聲明：本文爲CSDN博主「石頭StoneWang」的原創文章，遵循CC 4.0 BY-SA版權協議，轉載請附上原文出處鏈接及本聲明。
原文鏈接：https://blog.csdn.net/w8y56f/article/details/89554060