Java程序死鎖問(wèn)題定位與解決方法
更新時(shí)間：2024年11月27日 09:37:30 作者：徐俊生
死鎖是一種特定的程序狀態(tài),主要是由于循環(huán)依賴導(dǎo)致彼此一直處于等待中,而使得程序陷入僵局,相當(dāng)尷尬,死鎖不僅僅發(fā)生在線程之間,而對(duì)于資源獨(dú)占的進(jìn)程之間同樣可能出現(xiàn)死鎖,本文給大家介紹了Java程序死鎖問(wèn)題定位與解決方法,需要的朋友可以參考下
1. 死鎖概述
1.1 什么是死鎖
- 一定是發(fā)生在并發(fā)中；
- 互不相讓：當(dāng)兩個(gè)（或更多）線程（或進(jìn)程）相互持有對(duì)方所要的資源，又不主動(dòng)釋放，導(dǎo)致程序陷入無(wú)盡的阻塞，這就是死鎖。
1.2 死鎖產(chǎn)生的必要條件
導(dǎo)致死鎖的條件有四個(gè)，這四個(gè)條件同時(shí)滿足就會(huì)產(chǎn)生死鎖。
- 互斥條件：某些資源只能由一個(gè)線程獨(dú)占使用，其他線程在資源被占用時(shí)只能等待。
- 請(qǐng)求和保持條件：一個(gè)線程因請(qǐng)求資源而阻塞時(shí)，對(duì)已獲得的資源保持不放。
- 不可搶占條件：線程已獲得的資源，在未使用完之前，不能強(qiáng)行剝奪。
- 循環(huán)等待條件：若干線程之間形成一種頭尾相接的循環(huán)等待資源關(guān)系。
2. 死鎖的案例分析
public class Resource {
private String name;
private int count;
public Resource(String name) {
this.name = name;
}
public void staticResource() {
synchronized (this) {
System.out.println("static resource");
count++;
}
}
public void saveResource(Resource resource) {
synchronized (this) {
System.out.println("save resource：" + Thread.currentThread().getName());
resource.staticResource();
}
}
}
public class DeadLock {
public static void main(String[] args) {
Resource resource1 = new Resource("resource1");
Resource resource2 = new Resource("resource2");
Thread threadA = new Thread(() -> {
for (int i = 0; i < 100; i++) {
resource1.saveResource(resource2);
}
});
Thread threadB = new Thread(() -> {
for (int i = 0; i < 100; i++) {
resource2.saveResource(resource1);
}
});
threadA.start();
threadB.start();
}
}
打印結(jié)果：
save resource：Thread-0 save resource：Thread-1
死鎖原因分析：
- 線程 A 行為：
threadA在調(diào)用resource1.saveResource(resource2)時(shí)：- 首先鎖住了
resource1對(duì)象。 - 然后試圖鎖住
resource2對(duì)象，進(jìn)入其staticResource方法。
- 首先鎖住了
- 線程B行為：
threadB在調(diào)用resource2.saveResource(resource1)時(shí)：- 首先鎖住了
resource2對(duì)象。 - 然后試圖鎖住
resource1對(duì)象，進(jìn)入其staticResource方法。
- 首先鎖住了
- 死鎖發(fā)生的原因：
- 如果
threadA已經(jīng)鎖住resource1，并等待鎖住resource2，而此時(shí)threadB已經(jīng)鎖住resource2并等待鎖住resource1，就會(huì)發(fā)生循環(huán)等待。 - 兩個(gè)線程互相等待對(duì)方釋放鎖，從而陷入死鎖狀態(tài)。
3. 死鎖排查
- 首先，通過(guò)
jps命令，查看 Java 進(jìn)程的 pid。
C:\Users\shawn>jps 22568 24488 Launcher 10060 DeadLock 28076 Jps
- 然后，通過(guò)
jstack <pid>命令查看線程 dump 日志。當(dāng)發(fā)現(xiàn)死鎖時(shí)，可以在打印的 dump 日志中找到Found one Java-level deadlock:信息，根據(jù)信息的內(nèi)容可以分析死鎖出現(xiàn)的原因。
C:\Users\shawn>jstack 23128
2024-11-23 15:38:34
Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.321-b07 mixed mode):
=============================
Found one Java-level deadlock:
=============================
"Thread-1":
waiting to lock monitor 0x0000022b6c713f08 (object 0x000000076bdaa990, a com.atu.deadlock.Resource),
which is held by "Thread-0"
"Thread-0":
waiting to lock monitor 0x0000022b6c7169a8 (object 0x000000076bdaa9e8, a com.atu.deadlock.Resource),
which is held by "Thread-1"
Java stack information for the threads listed above:
===================================================
"Thread-1":
at com.atu.deadlock.Resource.staticResource(Resource.java:13)
- waiting to lock <0x000000076bdaa990> (a com.atu.deadlock.Resource)
at com.atu.deadlock.Resource.saveResource(Resource.java:21)
- locked <0x000000076bdaa9e8> (a com.atu.deadlock.Resource)
at com.atu.deadlock.DeadLock.lambda$main$1(DeadLock.java:18)
at com.atu.deadlock.DeadLock$$Lambda$2/1096979270.run(Unknown Source)
at java.lang.Thread.run(Thread.java:750)
"Thread-0":
at com.atu.deadlock.Resource.staticResource(Resource.java:13)
- waiting to lock <0x000000076bdaa9e8> (a com.atu.deadlock.Resource)
at com.atu.deadlock.Resource.saveResource(Resource.java:21)
- locked <0x000000076bdaa990> (a com.atu.deadlock.Resource)
at com.atu.deadlock.DeadLock.lambda$main$0(DeadLock.java:12)
at com.atu.deadlock.DeadLock$$Lambda$1/1324119927.run(Unknown Source)
at java.lang.Thread.run(Thread.java:750)
Found 1 deadlock.
4. 線上發(fā)生死鎖應(yīng)該怎么辦
- 首先保存案發(fā)現(xiàn)場(chǎng)，然后立刻重啟服務(wù)器（使用 java 相應(yīng)的命令把整個(gè)堆棧信息保存下來(lái)），不能進(jìn)一步影響用戶體驗(yàn)；
- 暫時(shí)保證線上服務(wù)的安全，然后再利用剛才保存的信息，排查死鎖，修改代碼，重新發(fā)版。
5. 常見(jiàn)死鎖修復(fù)策略
前面我們說(shuō)死鎖的四個(gè)必要條件，我們只需要破壞其中任意一個(gè)，就可以避免死鎖的產(chǎn)生。其中，互斥條件我們不可以破壞，因?yàn)檫@是互斥鎖的基本約束，其他三個(gè)條件都可以破壞。
- 破壞請(qǐng)求和保持條件：線程在請(qǐng)求開(kāi)始前，一次性申請(qǐng)所有的資源。
- 破壞不可搶占條件：占用部分資源的線程進(jìn)一步申請(qǐng)其他資源時(shí)，如果申請(qǐng)不到，可以主動(dòng)釋放它占有的資源。
- 破壞循環(huán)等待條件：靠按序申請(qǐng)資源來(lái)預(yù)防。按某一順序申請(qǐng)資源，釋放資源則反序釋放。破壞循環(huán)等待條件。
5.1 破壞請(qǐng)求和保持條件
要破壞占用資源所帶來(lái)的等待，可以一次性申請(qǐng)所有資源，保證同時(shí)申請(qǐng)這個(gè)操作是在一個(gè)臨界區(qū)中，然后通過(guò)一個(gè)單獨(dú)的角色來(lái)管理這個(gè)臨界區(qū)。
- 這個(gè)角色有兩個(gè)很重要的功能，就是同時(shí)申請(qǐng)資源和同時(shí)釋放資源，并且這個(gè)角色一定是一個(gè)單例。
先定義一個(gè) ApplyLock 類，用來(lái)實(shí)現(xiàn)統(tǒng)一鎖資源的申請(qǐng)，該類中有兩個(gè)方法：
- 一個(gè)是
applyLock()方法，用來(lái)申請(qǐng)鎖； - 另一個(gè)是
free()方法，用來(lái)統(tǒng)一釋放鎖。
public class ApplyLock {
private List<Object> list = new ArrayList<>();
public synchronized boolean applyLock(Resource resource1, Resource resource2) {
if (list.contains(resource1) || list.contains(resource2)) {
return false;
} else {
list.add(resource1);
list.add(resource2);
return true;
}
}
public synchronized void free(Resource resource1, Resource resource2) {
list.remove(resource1);
list.remove(resource2);
}
}
修改 Resource 類，定義一個(gè)全局唯一的 ApplyLock 實(shí)例，然后在 saveResource 中調(diào)用 applyLock() 方法和 free() 方法進(jìn)行統(tǒng)一鎖資源的獲取和釋放。
public class Resource {
private String name;
private int count;
static ApplyLock applyLock = new ApplyLock();
public Resource(String name) {
this.name = name;
}
public void staticResource() {
synchronized (this) {
System.out.println("static resource");
count++;
}
}
public void saveResource(Resource resource) {
applyLock.applyLock(this, resource);
try {
System.out.println("save resource：" + Thread.currentThread().getName());
resource.staticResource();
} finally {
applyLock.free(this, resource);
}
}
}
由于當(dāng)前涉及的相關(guān)資源都實(shí)現(xiàn)了一個(gè)統(tǒng)一的鎖資源獲取和釋放，從而打破了請(qǐng)求和保持條件。
5.2 破壞不可搶占條件
破壞不可搶占條件的核心是當(dāng)前線程能夠主動(dòng)釋放嘗試占有的資源，這一點(diǎn) synchronized無(wú)法實(shí)現(xiàn)。
- 原因是
synchronized在申請(qǐng)不到資源時(shí)會(huì)直接進(jìn)入阻塞狀態(tài)，一旦線程被阻塞就無(wú)法再釋放已經(jīng)占有的資源。 - 在
java.util.concurrent包中的Lock鎖可以輕松地解決這個(gè)問(wèn)題。Lock接口中有一個(gè)tryLock()方法可以嘗試搶占資源，如果搶占成功則返回 true，否則返回 false，而且這個(gè)過(guò)程不會(huì)阻塞當(dāng)前線程。
import java.util.concurrent.locks.ReentrantLock;
public class Resource {
private String name;
private int count;
ReentrantLock lock = new ReentrantLock();
public Resource(String name) {
this.name = name;
}
public void staticResource() {
if (lock.tryLock()) {
try {
System.out.println("static resource");
count++;
} finally {
lock.unlock();
}
} else {
System.out.println("搶鎖失敗");
}
}
public void saveResource(Resource resource) {
if (lock.tryLock()) {
try {
System.out.println("save resource：" + Thread.currentThread().getName());
resource.staticResource();
} finally {
lock.unlock();
}
} else {
System.out.println("搶鎖失敗");
}
}
}
5.3 破壞循環(huán)等待條件
破壞循環(huán)等待條件的基本思想是：把資源按照某種順序編號(hào)，所有鎖資源的申請(qǐng)都按照某種順序來(lái)獲取。 比如，可以根據(jù) hashCode 來(lái)確定加鎖順序，再根據(jù) hashCode 的大小確定加鎖的對(duì)象，實(shí)現(xiàn)代碼如下。
public class Resource {
private String name;
private int count;
public Resource(String name) {
this.name = name;
}
public void staticResource() {
synchronized (this) {
System.out.println("static resource");
count++;
}
}
public void saveResource(Resource resource) {
Resource lock = this.hashCode() > resource.hashCode() ? this : resource;
synchronized (lock) {
System.out.println("save resource：" + Thread.currentThread().getName());
resource.staticResource();
}
}
}
5.4 經(jīng)典的哲學(xué)家就餐問(wèn)題
如圖所示：
- 有 5 個(gè)哲學(xué)家圍坐在一張圓桌旁。
- 每個(gè)哲學(xué)家都有一個(gè)吃飯和思考的狀態(tài)。
- 圓桌上放著 5 根筷子（與哲學(xué)家數(shù)量相同）。
- 哲學(xué)家必須同時(shí)拿起兩根筷子（左手和右手各一根）才能吃飯，吃完后放下筷子繼續(xù)思考。
問(wèn)題描述：如果每個(gè)哲學(xué)家都拿起左邊的筷子并等待右邊的筷子，導(dǎo)致所有人相互等待，陷入死鎖。
- 編號(hào)為 0 的哲學(xué)家拿到編號(hào)為 0 的筷子，并等待編號(hào)為 1 的筷子。
- 編號(hào)為 1 的哲學(xué)家拿到編號(hào)為 1 的筷子，并等待編號(hào)為 2 的筷子。
- 編號(hào)為 2 的哲學(xué)家拿到編號(hào)為 2 的筷子，并等待編號(hào)為 3 的筷子。
- 編號(hào)為 3 的哲學(xué)家拿到編號(hào)為 3 的筷子，并等待編號(hào)為 4 的筷子。
- 編號(hào)為 4 的哲學(xué)家拿到編號(hào)為 4 的筷子，并等待編號(hào)為 0 的筷子。
哲學(xué)家就餐問(wèn)題（死鎖）:
public class DiningPhilosophers {
public static class Philosopher implements Runnable {
private Object leftChopstick;
private Object rightChopstick;
public Philosopher(Object leftChopstick, Object rightChopstick) {
this.leftChopstick = leftChopstick;
this.rightChopstick = rightChopstick;
}
@Override
public void run() {
while (true) {
//思考
try {
doAction("Thinking");
//吃飯
//拿起左邊筷子，拿起右邊筷子 放下右邊筷子 放下左邊筷子
synchronized (leftChopstick) {
doAction("Picked up left chopstick");
synchronized (rightChopstick) {
doAction("Picked up right chopstick -eating");
doAction("Put down right chopstick");
}
doAction("Put down left chopstick");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private void doAction(String action) throws InterruptedException {
System.out.println(Thread.currentThread().getName() + " " + action);
Thread.sleep((long) Math.random() * 10);
}
}
public static void main(String[] args) {
Philosopher[] philosophers = new Philosopher[5];
Object[] chopsticks = new Object[philosophers.length];
for (int i = 0; i < chopsticks.length; i++) {
chopsticks[i] = new Object();
}
for (int i = 0; i < philosophers.length; i++) {
Object leftChopstick = chopsticks[i];
Object rightChopstick = chopsticks[(i + 1) % chopsticks.length];
philosophers[i] = new Philosopher(leftChopstick, rightChopstick);
new Thread(philosophers[i], "哲學(xué)家" + (i + 1) + "號(hào)").start();
}
}
}
解決的方式有很多，這里我們通過(guò)改變一個(gè)哲學(xué)家拿筷子的順序，解決死鎖問(wèn)題。
哲學(xué)家就餐的換手方案：
public class DiningPhilosophersFix {
public static class Philosopher implements Runnable {
private Object leftChopstick;
private Object rightChopstick;
public Philosopher(Object leftChopstick, Object rightChopstick) {
this.leftChopstick = leftChopstick;
this.rightChopstick = rightChopstick;
}
@Override
public void run() {
while (true) {
//思考
try {
doAction("Thinking");
//吃飯
//拿起左邊筷子，拿起右邊筷子 放下右邊筷子 放下左邊筷子
synchronized (leftChopstick) {
doAction("Picked up left chopstick");
synchronized (rightChopstick) {
doAction("Picked up right chopstick -eating");
doAction("Put down right chopstick");
}
doAction("Put down left chopstick");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private void doAction(String action) throws InterruptedException {
System.out.println(Thread.currentThread().getName() + " " + action);
Thread.sleep((long) Math.random() * 10);
}
}
public static void main(String[] args) {
Philosopher[] philosophers = new Philosopher[5];
Object[] chopsticks = new Object[philosophers.length];
for (int i = 0; i < chopsticks.length; i++) {
chopsticks[i] = new Object();
}
for (int i = 0; i < philosophers.length; i++) {
Object leftChopstick = chopsticks[i];
Object rightChopstick = chopsticks[(i + 1) % chopsticks.length];
if (i == philosophers.length - 1) {
philosophers[i] = new Philosopher(rightChopstick, leftChopstick);
} else {
philosophers[i] = new Philosopher(leftChopstick, rightChopstick);
}
new Thread(philosophers[i], "哲學(xué)家" + (i + 1) + "號(hào)").start();
}
}
}
6. 實(shí)際工程中如何有效避免死鎖
- 設(shè)置超時(shí)時(shí)間：
Lock的tryLock(long timeout, TimeUnit unit)；synchronized不具備嘗試鎖的能力。
- 使用最小化鎖：減少鎖的數(shù)量和作用范圍，能顯著降低死鎖發(fā)生的概率。
- 避免嵌套鎖：盡量避免線程在持有一個(gè)鎖時(shí)嘗試獲取另一個(gè)鎖。
- 使用高級(jí)并發(fā)工具：
Semaphore、CountDownLatch、ReadWriteLock。
7. 其他活性故障
死鎖是最常見(jiàn)的活躍性問(wèn)題，除了死鎖之外，還有一些類似的問(wèn)題，會(huì)導(dǎo)致程序無(wú)法順利執(zhí)行，統(tǒng)稱為活躍性問(wèn)題。
7.1 活鎖
什么是活鎖：線程處于一種“忙碌但無(wú)效”的狀態(tài)，始終無(wú)法完成任務(wù)。（俗稱內(nèi)耗）
特點(diǎn)：
- 程序一直在運(yùn)行，但是一直在做沒(méi)有意義的工作。
活鎖代碼示例：
public class LiveLock {
static class Spoon {
private Diner owner; //就餐者
public synchronized void use() {
System.out.printf("%s has eaten!", owner.name);
}
public Spoon(Diner owner) {
this.owner = owner;
}
public Diner getOwner() {
return owner;
}
public void setOwner(Diner owner) {
this.owner = owner;
}
}
static class Diner {
private String name;
private boolean isHungry;
public Diner(String name) {
this.name = name;
isHungry = true;
}
public void eatWith(Spoon spoon, Diner spouse) {
while (isHungry) { //只有餓的情況下才能進(jìn)來(lái)
//問(wèn)題在此處：一直再謙讓
if (spouse.isHungry) {
System.out.println(name + ": 親愛(ài)的" + spouse.name + "你先吃吧");
spoon.setOwner(spouse);
continue;
}
spoon.use();
isHungry = false;
System.out.println(name + ": 我吃好了");
spoon.setOwner(spouse);
}
}
}
public static void main(String[] args) {
Diner husband = new Diner("牛郎");
Diner wife = new Diner("織女");
Spoon spoon = new Spoon(husband);
new Thread(new Runnable() {
@Override
public void run() {
husband.eatWith(spoon, wife);
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
wife.eatWith(spoon, husband);
}
}).start();
}
}
打印結(jié)果：
牛郎: 親愛(ài)的織女你先吃吧 織女: 親愛(ài)的牛郎你先吃吧 牛郎: 親愛(ài)的織女你先吃吧 織女: 親愛(ài)的牛郎你先吃吧 牛郎: 親愛(ài)的織女你先吃吧 織女: 親愛(ài)的牛郎你先吃吧 牛郎: 親愛(ài)的織女你先吃吧 織女: 親愛(ài)的牛郎你先吃吧 牛郎: 親愛(ài)的織女你先吃吧 織女: 親愛(ài)的牛郎你先吃吧 ...
解決：以太網(wǎng)的指數(shù)退避算法，加入隨機(jī)因素。
public class LiveLockFix {
static class Spoon {
private Diner owner; //就餐者
public synchronized void use() {
System.out.printf("%s has eaten!", owner.name);
}
public Spoon(Diner owner) {
this.owner = owner;
}
public Diner getOwner() {
return owner;
}
public void setOwner(Diner owner) {
this.owner = owner;
}
}
static class Diner {
private String name;
private boolean isHungry;
public Diner(String name) {
this.name = name;
isHungry = true;
}
public void eatWith(Spoon spoon, Diner spouse) {
while (isHungry) { //只有餓的情況下才能進(jìn)來(lái)
Random random = new Random();
//問(wèn)題在此處：一直再謙讓
if (spouse.isHungry && random.nextInt(10) < 9) {
System.out.println(name + ": 親愛(ài)的" + spouse.name + "你先吃吧");
spoon.setOwner(spouse);
continue;
}
spoon.use();
isHungry = false;
System.out.println(name + ": 我吃好了");
spoon.setOwner(spouse);
}
}
}
public static void main(String[] args) {
Diner husband = new Diner("牛郎");
Diner wife = new Diner("織女");
Spoon spoon = new Spoon(husband);
new Thread(new Runnable() {
@Override
public void run() {
husband.eatWith(spoon, wife);
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
wife.eatWith(spoon, husband);
}
}).start();
}
}
活鎖的解決方法：
- 增加隨機(jī)性：通過(guò)引入隨機(jī)的等待時(shí)間（如使用隨機(jī)退避算法），避免線程/進(jìn)程按照相同的模式重復(fù)操作。
- 設(shè)置重試次數(shù)或超時(shí)：為線程的嘗試次數(shù)或時(shí)間限制設(shè)置一個(gè)閾值。如果超過(guò)限制，則采用其他策略，如強(qiáng)制退出或降級(jí)處理。
7.2 饑餓
線程饑餓問(wèn)題其實(shí)指的公平性問(wèn)題。是指某個(gè)線程因無(wú)法獲取所需資源而無(wú)法執(zhí)行，一直處于等待狀態(tài)的情況。
饑餓代碼示例：
public class StarvationExample {
private static final Object lock = new Object();
public static void main(String[] args) {
Thread highPriorityThread = new Thread(() -> {
synchronized (lock) {
while (true) {
System.out.println("High priority thread is running...");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
Thread lowPriorityThread = new Thread(() -> {
synchronized (lock) {
while (true) {
System.out.println("Low priority thread is running...");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
highPriorityThread.setPriority(Thread.MAX_PRIORITY);
lowPriorityThread.setPriority(Thread.MIN_PRIORITY);
highPriorityThread.start();
lowPriorityThread.start();
}
}
問(wèn)題解析：
- 上述代碼中，高優(yōu)先級(jí)線程（highPriorityThread）由于持有 lock 鎖資源，它可能會(huì)導(dǎo)致低優(yōu)先級(jí)線程（lowPriorityThread）一直無(wú)法執(zhí)行，從而出現(xiàn)線程饑餓的現(xiàn)象。
線程饑餓原因：
- 資源分配不均： 如果一個(gè)線程的優(yōu)先級(jí)一直較低，而系統(tǒng)的調(diào)度策略總是優(yōu)先執(zhí)行高優(yōu)先級(jí)的線程，那么低優(yōu)先級(jí)線程就可能一直得不到執(zhí)行的機(jī)會(huì)，從而發(fā)生饑餓。
- 線程被無(wú)限阻塞：當(dāng)獲得鎖的線程需要執(zhí)行無(wú)限時(shí)間長(zhǎng)的操作時(shí)（比如 IO 或者無(wú)限循環(huán)），那么后面的線程將會(huì)被無(wú)限阻塞，導(dǎo)致被餓死。
饑餓的解決方法：
- 設(shè)置合適的線程優(yōu)先級(jí)
- 使用公平性調(diào)度算法
8. 總結(jié)
- 死鎖
- 特點(diǎn)：兩個(gè)或多個(gè)線程（進(jìn)程）相互等待對(duì)方釋放資源，導(dǎo)致所有線程都無(wú)法繼續(xù)執(zhí)行。
- 解決方法：避免一個(gè)線程持有多個(gè)資源的情況，或使用超時(shí)機(jī)制，如果一個(gè)線程在一定時(shí)間內(nèi)沒(méi)能獲得鎖，就放棄等待。
- 活鎖
- 特點(diǎn)：線程仍然在運(yùn)行，但由于不斷地響應(yīng)對(duì)方，始終沒(méi)有實(shí)際進(jìn)展。
- 解決方法：為避免活鎖，可以設(shè)置超時(shí)機(jī)制，或者使用協(xié)調(diào)機(jī)制來(lái)避免線程之間過(guò)度的反應(yīng)。
- 饑餓
- 特點(diǎn)：線程無(wú)法獲得執(zhí)行機(jī)會(huì)，但其他線程仍然在運(yùn)行，造成某些線程得不到資源。
- 解決方法：使用公平鎖或合理的優(yōu)先級(jí)策略，確保每個(gè)線程都有機(jī)會(huì)執(zhí)行，不會(huì)被長(zhǎng)時(shí)間忽略。
以上就是Java程序死鎖問(wèn)題定位與解決方法的詳細(xì)內(nèi)容，更多關(guān)于Java程序死鎖的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！
相關(guān)文章
淺談Spring Boot 2.0遷移指南主要注意點(diǎn)
Spring官方的Spring Boot 2變動(dòng)指南，主要是幫助您將應(yīng)用程序遷移到Spring Boot 2.0，具有一定的參考價(jià)值，感興趣的小伙伴們可以參考一下2018-10-10
mac系統(tǒng)剛安裝的idea打不開(kāi)的問(wèn)題及解決
這篇文章主要介紹了mac系統(tǒng)剛安裝的idea打不開(kāi)的問(wèn)題及解決方案,具有很好的參考價(jià)值,希望對(duì)大家有所幫助,如有錯(cuò)誤或未考慮完全的地方,望不吝賜教2023-09-09
本篇文章是對(duì)Java編程中異常處理的優(yōu)劣進(jìn)行了詳細(xì)的分析介紹，需要的朋友參考下2013-05-05
這篇文章主要介紹了JavaEE線程安全實(shí)現(xiàn)線程池方法，文章圍繞主題展開(kāi)詳細(xì)的內(nèi)容介紹，具有一定的參考價(jià)值，需要的小伙伴可以參考一下2022-06-06
這篇文章主要介紹了Java定義泛型方法,結(jié)合實(shí)例形式分析了java定義泛型的相關(guān)操作技巧與注意事項(xiàng),需要的朋友可以參考下2019-07-07
gradle配置國(guó)內(nèi)鏡像的實(shí)現(xiàn)
這篇文章主要介紹了gradle配置國(guó)內(nèi)鏡像的實(shí)現(xiàn)，文中通過(guò)示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來(lái)一起學(xué)習(xí)學(xué)習(xí)吧2020-07-07
這篇文章主要介紹了關(guān)于連接遠(yuǎn)程redis的流程,具有很好的參考價(jià)值,希望對(duì)大家有所幫助,如有錯(cuò)誤或未考慮完全的地方,望不吝賜教2024-06-06
java多線程實(shí)現(xiàn)同步鎖賣票實(shí)戰(zhàn)項(xiàng)目
本文主要介紹了java多線程實(shí)現(xiàn)同步鎖賣票實(shí)戰(zhàn)項(xiàng)目，文中通過(guò)示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來(lái)一起學(xué)習(xí)學(xué)習(xí)吧2023-01-01
這篇文章主要介紹了Java httpClient介紹以及使用示例，幫助大家更好的利用Java實(shí)現(xiàn)HTTP請(qǐng)求，感興趣的朋友可以了解下2020-10-10
java操作mongodb之多表聯(lián)查的實(shí)現(xiàn)($lookup)
這篇文章主要介紹了java操作mongodb之多表聯(lián)查的實(shí)現(xiàn)($lookup)，文中通過(guò)示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來(lái)一起學(xué)習(xí)學(xué)習(xí)吧2021-03-03