Zastanawiam się, jakie są alternatywne sposoby uniknięcia impasu w poniższym przykładzie. Poniższy przykład jest typowym problemem zakleszczenia konta bankowego. Jakie są lepsze sposoby rozwiązania tego problemu w praktyce?

class Account {
     double balance;
     int id;
     public Account(int id, double balance){
          this.balance = balance;
          this.id = id;
     }
     void withdraw(double amount){
          balance -= amount;
     } 
     void deposit(double amount){
          balance += amount;
     }
}
class Main{
     public static void main(String [] args){
           final Account a = new Account(1,1000);
           final Account b = new Account(2,300);
           Thread a = new Thread(){
                 public void run(){
                     transfer(a,b,200);
                 }
           };
           Thread b = new Thread(){
                 public void run(){
                     transfer(b,a,300);
                 }
           };
           a.start();
           b.start();
     }
     public static void transfer(Account from, Account to, double amount){
          synchronized(from){
               synchronized(to){
                    from.withdraw(amount);
                    to.deposit(amount);
               }
          }
     }
}

Zastanawiam się, czy rozwiąże problem zakleszczenia, jeśli oddzielę zagnieżdżony blokadę w mojej metodzie transferu, jak poniżej

 synchronized(from){
      from.withdraw(amount);
 }
 synchronized(to){
      to.deposit(amount);
 }