java - 让多个线程对数据集进行操作，而一个线程将其汇总

Question

我正在尝试实现一个我有一组账户的银行系统。有多个线程试图在账户之间转移资金，而一个线程不断地(或者更确切地说，在随机时间)试图总结银行中的总资金(所有账户余额的总和)。

解决这个问题的方法一开始听起来很明显；将 ReentrantReadWriteLocks 与 readLock 用于执行事务的线程，将 writeLock 用于执行求和的线程。然而，在以这种方式实现之后(参见下面的代码)，我发现性能/“事务吞吐量”大幅下降，甚至与仅使用一个线程进行事务相比也是如此。

• 上述实现代码:

  public class Account implements Compareable<Account>{
     private int id;
     private int balance;
  
     public Account(int id){
        this.id = id;
        this.balance = 0;
     }
  
     public synchronized int getBalance(){ return balance; }
  
     public synchronized setBalance(int balance){
        if(balance < 0){ throw new IllegalArgumentException("Negative balance"); }
        this.balance = balance;
     }
  
     public int getId(){ return this.id; }
  
     // To sort a collection of Accounts.
     public int compareTo(Account other){
        return (id < other.getId() ? -1 : (id == other.getId() ? 0 : 1));
     }
  }
  
  public class BankingSystem {
     protected List<Account> accounts;
     protected ReadWriteLock lock = new ReentrantReadWriteLock(); // !!
  
     public boolean transfer(Account from, Account to, int amount){
        if(from.getId() != to.getId()){
           synchronized(from){
              if(from.getBalance() < amount) return false;
              lock.readLock().lock(); // !!
              from.setBalance(from.getBalance() - amount);
           }
           synchronized(to){ 
              to.setBalance(to.getBalance() + amount);
              lock.readLock().unlock(); // !! 
           }
        }
        return true;
     }
  
     // Rest of class..
  }
  

请注意，这甚至还没有使用求和方法，因此永远不会获取 writeLock。如果我只删除标有 //!! 的行并且不调用求和方法，突然使用多线程的“传输吞吐量”比使用单线程时高很多，因为是目标。

我现在的问题是，如果我从不尝试获取 writeLock，为什么简单引入 readWriteLock 会使整个过程变慢那么多，而我所做的这里做错了，因为我找不到问题。

• 旁注:我已经问过关于这个问题的问题here , 但设法问错了问题。然而，我确实对我问的那个问题得到了一个惊人的答案。我决定不大幅降低问题质量，并为需要帮助的人保留这个很好的答案，我不会(再一次)编辑这个问题。相反，我打开这个问题，坚信这不是重复，而是完全不同的事情。

Answer 1

您通常会使用锁或同步，同时使用两者是不常见的。

要管理您的场景，您通常会在每个帐户上使用细粒度的锁，而不是像现在这样使用粗粒度的锁。您还可以使用监听器实现总计机制。

public interface Listener {

    public void changed(int oldValue, int newValue);
}

public class Account {

    private int id;
    private int balance;
    protected ReadWriteLock lock = new ReentrantReadWriteLock();
    List<Listener> accountListeners = new ArrayList<>();

    public Account(int id) {
        this.id = id;
        this.balance = 0;
    }

    public int getBalance() {
        int localBalance;
        lock.readLock().lock();
        try {
            localBalance = this.balance;
        } finally {
            lock.readLock().unlock();
        }
        return localBalance;
    }

    public void setBalance(int balance) {
        if (balance < 0) {
            throw new IllegalArgumentException("Negative balance");
        }
        // Keep track of the old balance for the listener.
        int oldValue = this.balance;
        lock.writeLock().lock();
        try {
            this.balance = balance;
        } finally {
            lock.writeLock().unlock();
        }
        if (this.balance != oldValue) {
            // Inform all listeners of any change.
            accountListeners.stream().forEach((l) -> {
                l.changed(oldValue, this.balance);
            });
        }
    }

    public boolean lock() throws InterruptedException {
        return lock.writeLock().tryLock(1, TimeUnit.SECONDS);
    }

    public void unlock() {
        lock.writeLock().unlock();
    }

    public void addListener(Listener l) {
        accountListeners.add(l);
    }

    public int getId() {
        return this.id;
    }

}

public class BankingSystem {

    protected List<Account> accounts;

    public boolean transfer(Account from, Account to, int amount) throws InterruptedException {
        if (from.getId() != to.getId()) {
            if (from.lock()) {
                try {
                    if (from.getBalance() < amount) {
                        return false;
                    }
                    if (to.lock()) {
                        try {
                            // We have write locks on both accounts.
                            from.setBalance(from.getBalance() - amount);
                            to.setBalance(to.getBalance() + amount);
                        } finally {
                            to.unlock();
                        }

                    } else {
                        // Not sure what to do - failed to lock the account.
                    }
                } finally {
                    from.unlock();
                }

            } else {
                // Not sure what to do - failed to lock the account.
            }
        }
        return true;
    }

    // Rest of class..
}

请注意，您可以在同一个线程中两次获取写锁 - 第二次也是允许的。锁仅排除来自其他线程的访问。