簡介
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()方法,我們可以使用這個方法來判斷是否能夠擷取到鎖,擷取不到就釋放已占有的鎖。
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));
}
}
}