簡介
java中爲了保證共享數據的安全性,我們引入了鎖的機制。有了鎖就有可能產生死鎖。
死鎖的原因就是多個線程鎖住了對方所需要的資源,然後現有的資源又沒有釋放,從而導致循環等待的情況。
通常來說如果不同的線程對加鎖和釋放鎖的順序不一致的話,就很有可能產生死鎖。
不同的加鎖順序
我們來看一個不同加鎖順序的例子:
public class DiffLockOrder {
private int amount;
public DiffLockOrder(int amount){
this.amount=amount;
}
public void transfer(DiffLockOrder target,int transferAmount){
synchronized (this){
synchronized (target){
if(amount< transferAmount){
System.out.println("餘額不足!");
}else{
amount=amount-transferAmount;
target.amount=target.amount+transferAmount;
}
}
}
}
}
上面的例子中,我們模擬一個轉賬的過程,amount用來表示用戶餘額。transfer用來將當前賬號的一部分金額轉移到目標對象中。
爲了保證在transfer的過程中,兩個賬戶不被別人修改,我們使用了兩個synchronized關鍵字,分別把transfer對象和目標對象進行鎖定。
看起來好像沒問題,但是我們沒有考慮在調用的過程中,transfer的順序是可以發生變化的:
DiffLockOrder account1 = new DiffLockOrder(1000);
DiffLockOrder account2 = new DiffLockOrder(500);
Runnable target1= ()->account1.transfer(account2,200);
Runnable target2= ()->account2.transfer(account1,100);
new Thread(target1).start();
new Thread(target2).start();
上面的例子中,我們定義了兩個account,然後兩個賬戶互相轉賬,最後很有可能導致互相鎖定,最後產生死鎖。
使用private類變量
使用兩個sync會有順序的問題,那麼有沒有辦法只是用一個sync就可以在所有的實例中同步呢?
有的,我們可以使用private的類變量,因爲類變量是在所有實例中共享的,這樣一次sync就夠了:
public class LockWithPrivateStatic {
private int amount;
private static final Object lock = new Object();
public LockWithPrivateStatic(int amount){
this.amount=amount;
}
public void transfer(LockWithPrivateStatic target, int transferAmount){
synchronized (lock) {
if (amount < transferAmount) {
System.out.println("餘額不足!");
} else {
amount = amount - transferAmount;
target.amount = target.amount + transferAmount;
}
}
}
}
使用相同的Order
我們產生死鎖的原因是無法控制上鎖的順序,如果我們能夠控制上鎖的順序,是不是就不會產生死鎖了呢?
帶着這個思路,我們給對象再加上一個id字段:
private final long id; // 唯一ID,用來排序
private static final AtomicLong nextID = new AtomicLong(0); // 用來生成ID
public DiffLockWithOrder(int amount){
this.amount=amount;
this.id = nextID.getAndIncrement();
}
在初始化對象的時候,我們使用static的AtomicLong類來爲每個對象生成唯一的ID。
在做transfer的時候,我們先比較兩個對象的ID大小,然後根據ID進行排序,最後安裝順序進行加鎖。這樣就能夠保證順序,從而避免死鎖。
public void transfer(DiffLockWithOrder target, int transferAmount){
DiffLockWithOrder fist, second;
if (compareTo(target) < 0) {
fist = this;
second = target;
} else {
fist = target;
second = this;
}
synchronized (fist){
synchronized (second){
if(amount< transferAmount){
System.out.println("餘額不足!");
}else{
amount=amount-transferAmount;
target.amount=target.amount+transferAmount;
}
}
}
}
釋放掉已佔有的鎖
死鎖是互相請求對方佔用的鎖,但是對方的鎖一直沒有釋放,我們考慮一下,如果獲取不到鎖的時候,自動釋放已佔用的鎖是不是也可以解決死鎖的問題呢?
因爲ReentrantLock有一個tryLock()方法,我們可以使用這個方法來判斷是否能夠獲取到鎖,獲取不到就釋放已佔有的鎖。
我們使用ReentrantLock來完成這個例子:
public class DiffLockWithReentrantLock {
private int amount;
private final Lock lock = new ReentrantLock();
public DiffLockWithReentrantLock(int amount){
this.amount=amount;
}
private void transfer(DiffLockWithReentrantLock target, int transferAmount)
throws InterruptedException {
while (true) {
if (this.lock.tryLock()) {
try {
if (target.lock.tryLock()) {
try {
if(amount< transferAmount){
System.out.println("餘額不足!");
}else{
amount=amount-transferAmount;
target.amount=target.amount+transferAmount;
}
break;
} finally {
target.lock.unlock();
}
}
} finally {
this.lock.unlock();
}
}
//隨機sleep一定的時間,保證可以釋放掉鎖
Thread.sleep(1000+new Random(1000L).nextInt(1000));
}
}
}
我們把兩個tryLock方法在while循環中,如果不能獲取到鎖就循環遍歷。
本文爲阿里雲原創內容,未經允許不得轉載。