新手Java——死锁模仿

Question

我正在尝试编写非常简单的程序来模拟简单的死锁，其中线程 A 等待资源 A 被线程 B 锁定，线程 B 等待资源 B 被线程 A 锁定。

这是我的代码:

//it will be my Shared resource
public class Account {
    private float amount;

    public void debit(double amount){
        this.amount-=amount;
    }

    public void credit(double amount){
        this.amount+=amount;
    }

}  

这是我的 runnable，它对上面的资源执行操作:

public class BankTransaction implements Runnable {
    Account fromAccount,toAccount;
    float ammount;
    public BankTransaction(Account fromAccount, Account toAccount,float ammount){
        this.fromAccount = fromAccount;
        this.toAccount = toAccount;
        this.ammount = ammount;
    }

    private void transferMoney(){
        synchronized(fromAccount){
            synchronized(toAccount){
                fromAccount.debit(ammount);
                toAccount.credit(ammount);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                e.printStackTrace();
                }
                System.out.println("Current Transaction Completed!!!");
            }
        }
    }

    @Override
    public void run() {
        transferMoney();
    }

}

最后是我的主课:

    public static void main(String[] args) {

    Account a = new Account();
    Account b = new Account();
    Thread thread1 = new Thread(new BankTransaction(a,b,500));

    Thread thread2 = new Thread(new BankTransaction(b,a,500));
       thread1.start();  
       thread2.start();  
System.out.println("Transactions Completed!!!");

    }
}

为什么这段代码运行执行成功而我没有死锁？

Answer 1

它有死锁的潜力 - 但是两个锁一起获得的速度如此之快，以至于一个线程可以在另一个线程有机会获得第一个锁之前获得两个锁。

在两个同步语句之间放置另一个 Thread.sleep(500); 调用，它确实死锁:两个线程都将进入“它们的”外部锁， sleep ，然后当他们醒来时，他们都会发现他们的“内部”锁已经被获取。

这是因为您的同步语句是反对称的:对于一个线程，外部同步锁是另一个线程的内部同步锁，反之亦然。