溫馨提示×
您好，登錄后才能下訂單哦！
點(diǎn)擊 登錄注冊(cè) 即表示同意《億速云用戶服務(wù)條款》
您好，登錄后才能下訂單哦！
這篇文章主要介紹了Java輪詢鎖使用時(shí)遇到的問題怎么解決的相關(guān)知識(shí)，內(nèi)容詳細(xì)易懂，操作簡(jiǎn)單快捷，具有一定借鑒價(jià)值，相信大家閱讀完這篇Java輪詢鎖使用時(shí)遇到的問題怎么解決文章都會(huì)有所收獲，下面我們一起來看看吧。
當(dāng)我們沒有使用輪詢鎖之前，可能會(huì)出現(xiàn)這樣的問題：
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class DeadLockByReentrantLock {
public static void main(String[] args) {
Lock lockA = new ReentrantLock(); // 創(chuàng)建鎖 A
Lock lockB = new ReentrantLock(); // 創(chuàng)建鎖 B
// 創(chuàng)建線程 1
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
lockA.lock(); // 加鎖
System.out.println("線程 1:獲取到鎖 A!");
try {
Thread.sleep(1000);
System.out.println("線程 1:等待獲取 B...");
lockB.lock(); // 加鎖
try {
System.out.println("線程 1:獲取到鎖 B!");
} finally {
lockA.unlock(); // 釋放鎖
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lockA.unlock(); // 釋放鎖
}
}
});
t1.start(); // 運(yùn)行線程
// 創(chuàng)建線程 2
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
lockB.lock(); // 加鎖
System.out.println("線程 2:獲取到鎖 B!");
try {
Thread.sleep(1000);
System.out.println("線程 2:等待獲取 A...");
lockA.lock(); // 加鎖
try {
System.out.println("線程 2:獲取到鎖 A!");
} finally {
lockA.unlock(); // 釋放鎖
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lockB.unlock(); // 釋放鎖
}
}
});
t2.start(); // 運(yùn)行線程
}
}以上代碼的執(zhí)行結(jié)果如下：
從上述結(jié)果可以看出，此時(shí)程序中出現(xiàn)了線程相互等待，并嘗試獲取對(duì)方（鎖）資源的情況，這就是典型的死鎖問題了。
當(dāng)出現(xiàn)死鎖問題之后，我們就可以使用輪詢鎖來解決它了，它的實(shí)現(xiàn)思路是通過輪詢的方式來獲取多個(gè)鎖，如果中途有任意一個(gè)鎖獲取失敗，則執(zhí)行回退操作，釋放當(dāng)前線程擁有的所有鎖，等待下一次重新執(zhí)行，這樣就可以避免多個(gè)線程同時(shí)擁有并霸占鎖資源了，從而直接解決了死鎖的問題，簡(jiǎn)易版的輪詢鎖實(shí)現(xiàn)如下：
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SolveDeadLockExample2 {
public static void main(String[] args) {
Lock lockA = new ReentrantLock(); // 創(chuàng)建鎖 A
Lock lockB = new ReentrantLock(); // 創(chuàng)建鎖 B
// 創(chuàng)建線程 1(使用輪詢鎖)
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
// 調(diào)用輪詢鎖
pollingLock(lockA, lockB);
}
});
t1.start(); // 運(yùn)行線程
// 創(chuàng)建線程 2
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
lockB.lock(); // 加鎖
System.out.println("線程 2:獲取到鎖 B!");
try {
Thread.sleep(1000);
System.out.println("線程 2:等待獲取 A...");
lockA.lock(); // 加鎖
try {
System.out.println("線程 2:獲取到鎖 A!");
} finally {
lockA.unlock(); // 釋放鎖
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lockB.unlock(); // 釋放鎖
}
}
});
t2.start(); // 運(yùn)行線程
}
/**
* 輪詢鎖
*/
private static void pollingLock(Lock lockA, Lock lockB) {
// 輪詢鎖
while (true) {
if (lockA.tryLock()) { // 嘗試獲取鎖
System.out.println("線程 1:獲取到鎖 A!");
try {
Thread.sleep(1000);
System.out.println("線程 1:等待獲取 B...");
if (lockB.tryLock()) { // 嘗試獲取鎖
try {
System.out.println("線程 1:獲取到鎖 B!");
} finally {
lockB.unlock(); // 釋放鎖
System.out.println("線程 1:釋放鎖 B.");
break;
}
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lockA.unlock(); // 釋放鎖
System.out.println("線程 1:釋放鎖 A.");
}
}
// 等待一秒再繼續(xù)執(zhí)行
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}以上代碼的執(zhí)行結(jié)果如下：
從上述結(jié)果可以看出，當(dāng)我們?cè)诔绦蛑惺褂幂喸冩i之后就不會(huì)出現(xiàn)死鎖的問題了，但以上輪詢鎖也并不是完美無缺的，下面我們來看看這個(gè)輪詢鎖會(huì)有什么樣的問題？
以上簡(jiǎn)易版的輪詢鎖，如果遇到有一個(gè)線程一直霸占或者長(zhǎng)時(shí)間霸占鎖資源的情況，就會(huì)導(dǎo)致這個(gè)輪詢鎖進(jìn)入死循環(huán)的狀態(tài)，它會(huì)嘗試一直獲取鎖資源，這樣就會(huì)造成新的問題，帶來不必要的性能開銷，具體示例如下。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SolveDeadLockExample {
public static void main(String[] args) {
Lock lockA = new ReentrantLock(); // 創(chuàng)建鎖 A
Lock lockB = new ReentrantLock(); // 創(chuàng)建鎖 B
// 創(chuàng)建線程 1(使用輪詢鎖)
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
// 調(diào)用輪詢鎖
pollingLock(lockA, lockB);
}
});
t1.start(); // 運(yùn)行線程
// 創(chuàng)建線程 2
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
lockB.lock(); // 加鎖
System.out.println("線程 2:獲取到鎖 B!");
try {
Thread.sleep(1000);
System.out.println("線程 2:等待獲取 A...");
lockA.lock(); // 加鎖
try {
System.out.println("線程 2:獲取到鎖 A!");
} finally {
lockA.unlock(); // 釋放鎖
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 如果此處代碼未執(zhí)行，線程 2 一直未釋放鎖資源
// lockB.unlock();
}
}
});
t2.start(); // 運(yùn)行線程
}
/**
* 輪詢鎖
*/
public static void pollingLock(Lock lockA, Lock lockB) {
while (true) {
if (lockA.tryLock()) { // 嘗試獲取鎖
System.out.println("線程 1:獲取到鎖 A!");
try {
Thread.sleep(1000);
System.out.println("線程 1:等待獲取 B...");
if (lockB.tryLock()) { // 嘗試獲取鎖
try {
System.out.println("線程 1:獲取到鎖 B!");
} finally {
lockB.unlock(); // 釋放鎖
System.out.println("線程 1:釋放鎖 B.");
break;
}
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lockA.unlock(); // 釋放鎖
System.out.println("線程 1:釋放鎖 A.");
}
}
// 等待一秒再繼續(xù)執(zhí)行
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}以上代碼的執(zhí)行結(jié)果如下：
從上述結(jié)果可以看出，線程 1 輪詢鎖進(jìn)入了死循環(huán)的狀態(tài)。
針對(duì)以上死循環(huán)的情況，我們可以改進(jìn)的思路有以下兩種：
添加最大次數(shù)限制：如果經(jīng)過了 n 次嘗試獲取鎖之后，還未獲取到鎖，則認(rèn)為獲取鎖失敗，執(zhí)行失敗策略之后終止輪詢（失敗策略可以是記錄日志或其他操作）；
添加最大時(shí)長(zhǎng)限制：如果經(jīng)過了 n 秒嘗試獲取鎖之后，還未獲取到鎖，則認(rèn)為獲取鎖失敗，執(zhí)行失敗策略之后終止輪詢。
以上策略任選其一就可以解決死循環(huán)的問題，出于實(shí)現(xiàn)成本的考慮，我們可以采用輪詢最大次數(shù)的方式來改進(jìn)輪詢鎖，
具體實(shí)現(xiàn)代碼如下：
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SolveDeadLockExample {
public static void main(String[] args) {
Lock lockA = new ReentrantLock(); // 創(chuàng)建鎖 A
Lock lockB = new ReentrantLock(); // 創(chuàng)建鎖 B
// 創(chuàng)建線程 1(使用輪詢鎖)
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
// 調(diào)用輪詢鎖
pollingLock(lockA, lockB, 3);
}
});
t1.start(); // 運(yùn)行線程
// 創(chuàng)建線程 2
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
lockB.lock(); // 加鎖
System.out.println("線程 2:獲取到鎖 B!");
try {
Thread.sleep(1000);
System.out.println("線程 2:等待獲取 A...");
lockA.lock(); // 加鎖
try {
System.out.println("線程 2:獲取到鎖 A!");
} finally {
lockA.unlock(); // 釋放鎖
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 線程 2 忘記釋放鎖資源
// lockB.unlock(); // 釋放鎖
}
}
});
t2.start(); // 運(yùn)行線程
}
/**
* 輪詢鎖
*
* maxCount：最大輪詢次數(shù)
*/
public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {
// 輪詢次數(shù)計(jì)數(shù)器
int count = 0;
while (true) {
if (lockA.tryLock()) { // 嘗試獲取鎖
System.out.println("線程 1:獲取到鎖 A!");
try {
Thread.sleep(1000);
System.out.println("線程 1:等待獲取 B...");
if (lockB.tryLock()) { // 嘗試獲取鎖
try {
System.out.println("線程 1:獲取到鎖 B!");
} finally {
lockB.unlock(); // 釋放鎖
System.out.println("線程 1:釋放鎖 B.");
break;
}
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lockA.unlock(); // 釋放鎖
System.out.println("線程 1:釋放鎖 A.");
}
}
// 判斷是否已經(jīng)超過最大次數(shù)限制
if (count++ > maxCount) {
// 終止循環(huán)
System.out.println("輪詢鎖獲取失敗,記錄日志或執(zhí)行其他失敗策略");
return;
}
// 等待一秒再繼續(xù)嘗試獲取鎖
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}以上代碼的執(zhí)行結(jié)果如下：
從以上結(jié)果可以看出，當(dāng)我們改進(jìn)之后，輪詢鎖就不會(huì)出現(xiàn)死循環(huán)的問題了，它會(huì)嘗試一定次數(shù)之后終止執(zhí)行。
我們以上的輪詢鎖的輪詢等待時(shí)間是固定時(shí)間，如下代碼所示：
// 等待 1s 再嘗試獲取（輪詢）鎖
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}這樣在特殊情況下會(huì)造成線程餓死的問題，也就是輪詢鎖一直獲取不到鎖的問題，比如以下示例。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SolveDeadLockExample {
public static void main(String[] args) {
Lock lockA = new ReentrantLock(); // 創(chuàng)建鎖 A
Lock lockB = new ReentrantLock(); // 創(chuàng)建鎖 B
// 創(chuàng)建線程 1(使用輪詢鎖)
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
// 調(diào)用輪詢鎖
pollingLock(lockA, lockB, 3);
}
});
t1.start(); // 運(yùn)行線程
// 創(chuàng)建線程 2
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
while (true) {
lockB.lock(); // 加鎖
System.out.println("線程 2:獲取到鎖 B!");
try {
System.out.println("線程 2:等待獲取 A...");
lockA.lock(); // 加鎖
try {
System.out.println("線程 2:獲取到鎖 A!");
} finally {
lockA.unlock(); // 釋放鎖
}
} finally {
lockB.unlock(); // 釋放鎖
}
// 等待一秒之后繼續(xù)執(zhí)行
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
t2.start(); // 運(yùn)行線程
}
/**
* 輪詢鎖
*/
public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {
// 循環(huán)次數(shù)計(jì)數(shù)器
int count = 0;
while (true) {
if (lockA.tryLock()) { // 嘗試獲取鎖
System.out.println("線程 1:獲取到鎖 A!");
try {
Thread.sleep(100); // 等待 0.1s(獲取鎖需要的時(shí)間)
System.out.println("線程 1:等待獲取 B...");
if (lockB.tryLock()) { // 嘗試獲取鎖
try {
System.out.println("線程 1:獲取到鎖 B!");
} finally {
lockB.unlock(); // 釋放鎖
System.out.println("線程 1:釋放鎖 B.");
break;
}
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lockA.unlock(); // 釋放鎖
System.out.println("線程 1:釋放鎖 A.");
}
}
// 判斷是否已經(jīng)超過最大次數(shù)限制
if (count++ > maxCount) {
// 終止循環(huán)
System.out.println("輪詢鎖獲取失敗,記錄日志或執(zhí)行其他失敗策略");
return;
}
// 等待一秒再繼續(xù)嘗試獲取鎖
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}以上代碼的執(zhí)行結(jié)果如下：
從上述結(jié)果可以看出，線程 1（輪詢鎖）一直未成功獲取到鎖，造成這種結(jié)果的原因是：線程 1 每次輪詢的等待時(shí)間為固定的 1s，而線程 2 也是相同的頻率，每 1s 獲取一次鎖，這樣就會(huì)導(dǎo)致線程 2 會(huì)一直先成功獲取到鎖，而線程 1 則會(huì)一直處于“餓死”的情況，執(zhí)行流程如下圖所示：
接下來，我們可以將輪詢鎖的固定等待時(shí)間，改進(jìn)為固定時(shí)間 + 隨機(jī)時(shí)間的方式，這樣就可以避免因?yàn)楂@取鎖的頻率一致，而造成輪詢鎖“餓死”的問題了，具體實(shí)現(xiàn)代碼如下：
import java.util.Random;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SolveDeadLockExample {
private static Random rdm = new Random();
public static void main(String[] args) {
Lock lockA = new ReentrantLock(); // 創(chuàng)建鎖 A
Lock lockB = new ReentrantLock(); // 創(chuàng)建鎖 B
// 創(chuàng)建線程 1(使用輪詢鎖)
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
// 調(diào)用輪詢鎖
pollingLock(lockA, lockB, 3);
}
});
t1.start(); // 運(yùn)行線程
// 創(chuàng)建線程 2
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
while (true) {
lockB.lock(); // 加鎖
System.out.println("線程 2:獲取到鎖 B!");
try {
System.out.println("線程 2:等待獲取 A...");
lockA.lock(); // 加鎖
try {
System.out.println("線程 2:獲取到鎖 A!");
} finally {
lockA.unlock(); // 釋放鎖
}
} finally {
lockB.unlock(); // 釋放鎖
}
// 等待一秒之后繼續(xù)執(zhí)行
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
t2.start(); // 運(yùn)行線程
}
/**
* 輪詢鎖
*/
public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {
// 循環(huán)次數(shù)計(jì)數(shù)器
int count = 0;
while (true) {
if (lockA.tryLock()) { // 嘗試獲取鎖
System.out.println("線程 1:獲取到鎖 A!");
try {
Thread.sleep(100); // 等待 0.1s(獲取鎖需要的時(shí)間)
System.out.println("線程 1:等待獲取 B...");
if (lockB.tryLock()) { // 嘗試獲取鎖
try {
System.out.println("線程 1:獲取到鎖 B!");
} finally {
lockB.unlock(); // 釋放鎖
System.out.println("線程 1:釋放鎖 B.");
break;
}
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lockA.unlock(); // 釋放鎖
System.out.println("線程 1:釋放鎖 A.");
}
}
// 判斷是否已經(jīng)超過最大次數(shù)限制
if (count++ > maxCount) {
// 終止循環(huán)
System.out.println("輪詢鎖獲取失敗,記錄日志或執(zhí)行其他失敗策略");
return;
}
// 等待一定時(shí)間(固定時(shí)間 + 隨機(jī)時(shí)間)之后再繼續(xù)嘗試獲取鎖
try {
Thread.sleep(300 + rdm.nextInt(8) * 100); // 固定時(shí)間 + 隨機(jī)時(shí)間
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}以上代碼的執(zhí)行結(jié)果如下：
從上述結(jié)果可以看出，線程 1（輪詢鎖）加入隨機(jī)等待時(shí)間之后就不會(huì)出現(xiàn)線程餓死的問題了。
關(guān)于“Java輪詢鎖使用時(shí)遇到的問題怎么解決”這篇文章的內(nèi)容就介紹到這里，感謝各位的閱讀！相信大家對(duì)“Java輪詢鎖使用時(shí)遇到的問題怎么解決”知識(shí)都有一定的了解，大家如果還想學(xué)習(xí)更多知識(shí)，歡迎關(guān)注億速云行業(yè)資訊頻道。
免責(zé)聲明：本站發(fā)布的內(nèi)容（圖片、視頻和文字）以原創(chuàng)、轉(zhuǎn)載和分享為主，文章觀點(diǎn)不代表本網(wǎng)站立場(chǎng)，如果涉及侵權(quán)請(qǐng)聯(lián)系站長(zhǎng)郵箱：is@yisu.com進(jìn)行舉報(bào)，并提供相關(guān)證據(jù)，一經(jīng)查實(shí)，將立刻刪除涉嫌侵權(quán)內(nèi)容。
億速云公眾號(hào)
手機(jī)網(wǎng)站二維碼