两个对象上的Java同步会导致死锁

Question

我需要在账户之间实现一些基本的资金转移逻辑。为了保持转账的一致性，我利用了同步锁。

这是帐户对象：

class Account {
    UUID id;
    double balance;
}

这是在transfer worker类中：

    public void transfer(Account source, Account target) throws InterruptedException {
        Object firstLock = target.id.compareTo(source.id)  > 0 ? target : source;
        Object secondLock = target.id.compareTo(source.id)  < 0 ? target : source;
        synchronized (firstLock) {
            synchronized (secondLock) {
                // Money tranfer logic
            }   
        }
    }

我的问题是，如果source Account没有足够的资金，我计划等待该线程，直到它从其他运营中获得资金。对于这个，我一直在等待源帐户。但它以死锁告终，因为目标帐户锁仍在我的帐户上。我怎样才能做到这一点？你能告诉我解决这个问题的正确方法吗？

这就是我试图推迟资金转移的来源账户

    public void transfer(Account source, Account target) throws InterruptedException {
        Object firstLock = target.id.compareTo(source.id)  > 0 ? target : source;
        Object secondLock = target.id.compareTo(source.id)  < 0 ? target : source;
        synchronized (firstLock) {
            synchronized (secondLock) {
                while(source.balance <= 0 ) {
                    source.wait();
                }
                
                // Money tranfer logic
                
                source.notifyAll();
            }   
        }
    }

谢谢。

Answer 1

每当您运行任何等待代码时，您都需要处理InterruptedExctive。此外，在调试时添加特定的等待时间也是一个很好的做法，这样您就可以在特定的等待时间后重新加载您的当时循环。
以下是一个修改代码的示例，它可能会帮助您

synchronized (firstLock) {
        synchronized (secondLock) {
            while(s.balance <= 0 ) {
                
                //surround with InterruptedException otherwise code won't execute
                try {
                    s.wait(1000); // it is good to wait for specific milliseconds, in this case it's 1000 millis.
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            
            // Money transfer logic
            
            s.notifyAll();
        }   
    }
    

对不起，但是你已经改变了你的问题，所以我也在更新我的答案

这里新添加的代码，你不能使用静态源代码，目标。当循环运行时，你需要从数据库更新。

public class Z {
public static void main(String a[]){

    Account s = new Account("1");
    Account t = new Account("4");
    
    try {
        transfer(s, t);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }


}
public static void transfer(Account source, Account target) throws InterruptedException {
    Account firstLock = target.id.compareTo(source.id)  > 0 ? target : source;
    Account secondLock = target.id.compareTo(source.id)  < 0 ? target : source;

    double sourceBalance = 0;
    double targetBalance = 0;

    synchronized (firstLock) {
        synchronized (secondLock) {
            while(sourceBalance <= 4 ) {
                source.wait(1000);
                System.out.println("waiting... ");
                sourceBalance = sourceBalance+1; //get source balance from somewhere else realtime. for me im just updating
            }
            
            // Money tranfer logic
            targetBalance = 0; //get target balance from server or where you stored;
            targetBalance +=sourceBalance; 
            //send target balance where you want
            System.out.println("Money transferred");
            
            source.notifyAll();
        }   
    }
}


}
class Account {
    String id;
    public Account(String id){
        this.id = id;
    }
}