Java同步：在账户对之间原子移动资金？

Question

我怎样才能把钱从一个账户转到另一个账户？上课时间：

public class Account {
    public Account(BigDecimal initialAmount) {...}
    public BigDecimal getAmount() {...}
    public void setAmount(BigDecimal amount) {...}
}

我希望得到以下伪代码：

public boolean transfer(Account from, Account to, BigDecimal amount) {
    BigDecimal fromValue = from.getAmount();
    if (amount.compareTo(fromValue) < 0)
         return false;
    BigDecimal toValue = to.getAmount();
    from.setAmount(fromValue.add(amount.negate()));
    to.setAmount(toValue.add(amount));
    return true;
}

在单线程（或顺序）环境中安全地更新帐户。

在多线程/并发环境中，我看到了危险情况：

acc1 --> acc2  ||  acc2 --> acc1
acc1 --> acc2  ||  acc2 --> acc3  ||  acc3 --> acc1
...

最简单的解决方案是阻止共享对象，但对于以下情况，这将是低效的：

acc1 --> acc2  ||  acc3 --> acc4  and  acc1 != acc3 and acc2 != acc4

我希望独立的传输是并行进行的。

更新似乎建议的解决方案：

synchronize (acc1) {
   synchronize (acc2) {
     ....
   }
}

导致死锁，因为两个锁被依次获取。。。

更新2“在多线程环境中安全更新帐户”到底是什么意思？唯一担心的是这些账户最终不会出现负资金，还是存在其他问题？

如果acc1（2）；acc2（3）和acc1--1--

您希望一次有多少并发事务？1000-10000——所以锁定共享对象是没有效率的。




Answer 1

我建议创建一个方法帐户。提取（金额），如果没有足够的资金，就会抛出异常。此方法需要在帐户本身上同步。

编辑：

还需要一个账户。在接收帐户实例上同步的存款（金额）方法。

基本上，这将导致在取款时锁定第一个账户，然后在存款时锁定另一个收款账户。所以有两把锁，但不能同时锁。

代码示例：假设提取/存款是同步的，并返回布尔成功状态，而不是抛出异常。

public boolean transfer(Account from, Account to, BigDecimal amount) {
    boolean success = false;
    boolean withdrawn = false;
    try {
        if (from.withdraw(amount)) {
            withdrawn = true;
            if (to.deposit(amount)) {
                success = true;
            }
        }
    } finally {
        if (withdrawn && !success) {
            from.deposit(amount);
        }
    }

    return success;
}

Answer 2

一种方法是有一个交易日志。在转移资金之前，你需要在每个账户的交易日志中写入你打算做的事情。日志应该包含：从账户中取出的金额，以及日志对之间共享的锁。

最初，锁应该处于阻塞状态。您创建了日志对，一个带有金额为X，另一个带有金额为-X，并且两者共享一个锁。然后将日志条目发送到各自账户的收件箱，从其中取出资金的账户应该保留该金额。一旦您确认它们是安全交付的，然后释放锁。锁被释放的那一刻，您就处于无法返回的时刻。然后账户应该自行解决。

如果任何一方希望在释放锁之前的任何时候交易失败，那么只需删除日志并将预留金额返回主余额。

这种方法可能有点繁重，但它也适用于分布式场景，在这种场景中，帐户实际上位于不同的机器中，并且收件箱实际上必须保持不变，以确保在任何机器意外崩溃/脱机时，钱永远不会丢失。其一般技术称为两相锁定。

Answer 3

一个简单的解决方案可以是每个帐户使用一个锁，但是为了避免死锁，您必须总是以相同的顺序获取锁。因此，您可以有一个最终的帐户ID，并首先获取ID较小的帐户的锁：

public void transfer(Account acc1, Account acc2, BigDecimal value) {
    Object lock1 = acc1.ID < acc2.ID ? acc1.LOCK : acc2.LOCK;
    Object lock2 = acc1.ID < acc2.ID ? acc2.LOCK : acc1.LOCK;
    synchronized (lock1) {
       synchronized (lock2) {
          acc1.widrawal(value);
          acc2.send(value);
       }
    }
}