Java?輪詢鎖使用時(shí)遇到問(wèn)題解決方案
更新時(shí)間：2022年05月11日 17:16:21 作者：??Java中文社群????
這篇文章主要介紹了Java?輪詢鎖使用時(shí)遇到問(wèn)題解決方案，當(dāng)我們遇到死鎖之后，除了可以手動(dòng)重啟程序解決之外，還可以考慮使用順序鎖和輪詢鎖，但是過(guò)程也會(huì)遇到一些問(wèn)題，接下來(lái)我們一起進(jìn)入下面文章了解解決方案，需要的小伙伴可以參考一下
前言：
當(dāng)我們遇到死鎖之后，除了可以手動(dòng)重啟程序解決之外，還可以考慮使用順序鎖和輪詢鎖，這部分的內(nèi)容可以參考上一篇文章Java 死鎖解決方案順序鎖和輪詢鎖，這里就不再贅述了。然而，輪詢鎖在使用的過(guò)程中，如果使用不當(dāng)會(huì)帶來(lái)新的嚴(yán)重問(wèn)題，所以本篇我們就來(lái)了解一下這些問(wèn)題，以及相應(yīng)的解決方案。
問(wèn)題演示
當(dāng)我們沒(méi)有使用輪詢鎖之前，可能會(huì)出現(xiàn)這樣的問(wè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ì)方（鎖）資源的情況，這就是典型的死鎖問(wèn)題了。
簡(jiǎn)易版輪詢鎖
當(dāng)出現(xiàn)死鎖問(wèn)題之后，我們就可以使用輪詢鎖來(lái)解決它了，它的實(shí)現(xiàn)思路是通過(guò)輪詢的方式來(lái)獲取多個(gè)鎖，如果中途有任意一個(gè)鎖獲取失敗，則執(zhí)行回退操作，釋放當(dāng)前線程擁有的所有鎖，等待下一次重新執(zhí)行，這樣就可以避免多個(gè)線程同時(shí)擁有并霸占鎖資源了，從而直接解決了死鎖的問(wèn)題，簡(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)死鎖的問(wèn)題了，但以上輪詢鎖也并不是完美無(wú)缺的，下面我們來(lái)看看這個(gè)輪詢鎖會(huì)有什么樣的問(wèn)題？
問(wèn)題1：死循環(huán)
以上簡(jiǎn)易版的輪詢鎖，如果遇到有一個(gè)線程一直霸占或者長(zhǎng)時(shí)間霸占鎖資源的情況，就會(huì)導(dǎo)致這個(gè)輪詢鎖進(jìn)入死循環(huán)的狀態(tài)，它會(huì)嘗試一直獲取鎖資源，這樣就會(huì)造成新的問(wèn)題，帶來(lái)不必要的性能開(kāi)銷，具體示例如下。
反例
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)。
優(yōu)化版
針對(duì)以上死循環(huán)的情況，我們可以改進(jìn)的思路有以下兩種：
- 添加最大次數(shù)限制：如果經(jīng)過(guò)了 n 次嘗試獲取鎖之后，還未獲取到鎖，則認(rèn)為獲取鎖失敗，執(zhí)行失敗策略之后終止輪詢（失敗策略可以是記錄日志或其他操作）；
- 添加最大時(shí)長(zhǎng)限制：如果經(jīng)過(guò)了 n 秒嘗試獲取鎖之后，還未獲取到鎖，則認(rèn)為獲取鎖失敗，執(zhí)行失敗策略之后終止輪詢。
以上策略任選其一就可以解決死循環(huán)的問(wèn)題，出于實(shí)現(xiàn)成本的考慮，我們可以采用輪詢最大次數(shù)的方式來(lái)改進(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)超過(guò)最大次數(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)的問(wèn)題了，它會(huì)嘗試一定次數(shù)之后終止執(zhí)行。
問(wèn)題2：線程餓死
我們以上的輪詢鎖的輪詢等待時(shí)間是固定時(shí)間，如下代碼所示：
// 等待 1s 再嘗試獲?。ㄝ喸儯╂i
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}這樣在特殊情況下會(huì)造成線程餓死的問(wèn)題，也就是輪詢鎖一直獲取不到鎖的問(wè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() {
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)超過(guò)最大次數(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í)行流程如下圖所示：
優(yōu)化版
接下來(lái)，我們可以將輪詢鎖的固定等待時(shí)間，改進(jìn)為固定時(shí)間 + 隨機(jī)時(shí)間的方式，這樣就可以避免因?yàn)楂@取鎖的頻率一致，而造成輪詢鎖“餓死”的問(wè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)超過(guò)最大次數(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)線程餓死的問(wèn)題了。
總結(jié)
本文我們介紹了輪詢鎖的用途，用于解決死鎖問(wèn)題，但簡(jiǎn)易版的輪詢鎖在某些情況下會(huì)造成死循環(huán)和線程餓死的問(wèn)題，因此我們對(duì)輪詢鎖進(jìn)行了優(yōu)化，給輪詢鎖加入了最大輪詢次數(shù)，以及隨機(jī)輪詢等待時(shí)間，這樣就可以解決因?yàn)橐胼喸冩i而造成的新問(wèn)題了，這樣就可以愉快的使用它來(lái)解決死鎖的問(wèn)題了。
到此這篇關(guān)于Java 輪詢鎖使用時(shí)遇到問(wèn)題解決方案的文章就介紹到這了,更多相關(guān)Java 輪詢鎖內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
您可能感興趣的文章:
- java?常規(guī)輪詢長(zhǎng)輪詢Long?polling實(shí)現(xiàn)示例詳解
- Java實(shí)現(xiàn)一個(gè)簡(jiǎn)單的長(zhǎng)輪詢的示例代碼
- Java servlet通過(guò)事件驅(qū)動(dòng)進(jìn)行高性能長(zhǎng)輪詢?cè)斀?/a>
- Java?死鎖解決方案順序鎖和輪詢鎖
- Java實(shí)現(xiàn)平滑加權(quán)輪詢算法之降權(quán)和提權(quán)詳解
- Java負(fù)載均衡算法實(shí)現(xiàn)之輪詢和加權(quán)輪詢
- Java如何使用ReentrantLock實(shí)現(xiàn)長(zhǎng)輪詢
- Java 利用DeferredResult實(shí)現(xiàn)http輪詢實(shí)時(shí)返回?cái)?shù)據(jù)接口
- 基于Rxjava實(shí)現(xiàn)輪詢定時(shí)器
- 告別無(wú)盡等待：Java中的輪詢終止技巧
相關(guān)文章
這篇文章主要為大家剖析介紹了Fork?join并發(fā)框架工作竊取算法的示例，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪2022-06-06
解決idea導(dǎo)入maven項(xiàng)目缺少jar包的問(wèn)題方法
這篇文章主要介紹了解決idea導(dǎo)入maven項(xiàng)目缺少jar包的問(wèn)題，文中通過(guò)示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來(lái)一起學(xué)習(xí)學(xué)習(xí)吧2020-06-06
WebSocket無(wú)法注入屬性的問(wèn)題及解決方案
這篇文章主要介紹了WebSocket無(wú)法注入屬性的問(wèn)題及解決方法,本文通過(guò)示例代碼給大家介紹的非常詳細(xì),對(duì)大家的學(xué)習(xí)或工作具有一定的參考借鑒價(jià)值,需要的朋友可以參考下2023-09-09
這篇文章主要為大家詳細(xì)介紹了Java實(shí)現(xiàn)并查集，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價(jià)值，感興趣的小伙伴們可以參考一下2020-07-07
本文主要介紹了Java里的callable的實(shí)現(xiàn)原理，文中通過(guò)示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來(lái)一起學(xué)習(xí)學(xué)習(xí)吧2024-03-03
這篇文章主要介紹了Spring與Mybatis基于注解整合Redis的方法,本文通過(guò)實(shí)例給大家介紹的非常詳細(xì)，具有參考借鑒價(jià)值，需要的朋友可以參考下2016-09-09
這篇文章主要介紹了Spring Framework常用面試題及答案匯總,文中通過(guò)示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友可以參考下2020-06-06
Hutool開(kāi)發(fā)MapUtil工具類使用示例
這篇文章主要為大家介紹了Hutool開(kāi)發(fā)MapUtil工具類使用示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪2022-10-10
本文首先對(duì)Java集合類框架做了簡(jiǎn)單說(shuō)明，之后對(duì)主要類和為API做了介紹:Collection、List、Set、AbstractCollection、AbstractList、AbstractSet、Iterator、ListIterator。2013-11-11
mybatis映射和實(shí)際類型不一致的問(wèn)題
這篇文章主要介紹了mybatis映射和實(shí)際類型不一致的問(wèn)題，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。如有錯(cuò)誤或未考慮完全的地方，望不吝賜教2021-11-11