尽管保护写操作仍获取竞争条件 - Java

Question

使用 java.util.concurrent.locks.ReentrantLock 库如下：

两个线程生成一个随机数，并用它来更新存储在类 Accounts 中的共享变量 account1 和 account2 - 锁用于保护对共享变量的

package osproj221;
import java.util.concurrent.locks.ReentrantLock;

public class Accounts {
    private int account1,account2;
    private final ReentrantLock mutex;

    public Accounts(){
        account1=account2=0;
        mutex = new ReentrantLock();
    }

    public void updateAccounts(int amt){
        try{
            mutex.lock();
            account1 += amt;
            account2 -= amt;
        }catch(Exception ex){
            System.out.println(ex);
        }finally{mutex.unlock();}
    }

    public int getAccount1(){
        return this.account1;
    }

    public int getAccount2(){
        return this.account2;
    }
}

写入线程实现 Runnable 接口如下：

package osproj221;
import java.util.Random;

public class RaceThread implements Runnable {

    private Random myRand = new Random();
    private int counter = 0;
    private Accounts accounts;

    public RaceThread(Accounts accounts){
        this.accounts = accounts;
    }

    public void run(){

        do{
            int r = myRand.nextInt(300);
            r = Math.abs(r);
            accounts.updateAccounts(r);
            counter++;
        }while((accounts.getAccount1() + accounts.getAccount2() == 0));

        System.out.println(counter + " " + accounts.getAccount1() + " " + accounts.getAccount2());
    }

}

最后我的 Main 类

package osproj221;

public class Main {

    public static void main(String[] args) {
        Accounts myAccounts = new Accounts();

        Thread t1 = new Thread(new RaceThread(myAccounts));
        Thread t2 = new Thread(new RaceThread(myAccounts));

        t1.start();
        t2.start();

        try{
            t1.join();
            t2.join();
        }catch(Exception ex){
            System.out.println(ex);
        }

        System.out.println(myAccounts.getAccount1() + " " + myAccounts.getAccount2());

    }

}

看起来比我想象的要长一些 - 抱歉。我希望两个线程都不会终止，因为 account1+account2 应始终 = 0，因为互斥体负责保护 account1 和 account2 的更新。似乎发生的情况是，其中一个线程退出，因为它未满足 account1+account2==0 条件，而另一个线程无限期地继续。我很困惑！

Answer 1

这是因为你没有锁定吸气剂上的读取。这意味着线程 2 可以读取不一致状态的数据，而线程 1 正在更新数据（在 += 和 -= 之间）。
该问题可能发生如下：

线程 1：

1. updateAccounts(5);
2. 获取锁定
3. 账户1 += 5; ->账户1 = 0 + 5； ->账户1 = 5；

线程 2：

1. getAccount1() <- 返回 5
2. getAccount2() <- 返回 0
3. 5+0 != 0 -->退出

线程 1：

1. account2 -= 5 ->账户2 = 0-5 ->账户2 = -5；
2. 释放锁定。

解决方案：
不幸的是，您不能简单地单独同步您的 getter，我建议使用一种新的 get 方法：

public int getAccountsSum() {
    try {
        mutex.lock();
        return this.account1 + this.account2;
    } finally { mutex.unlock(); }

并在 RaceThread.run() 中将 while 条件更改为：

    }while((accounts.getAccountsSum() == 0));

Answer 2

仅仅同步你的写入是不够的；您还需要使用相同的锁/监视器来同步读取。

如果不这样做，可能会发生不好的事情：

• 无法保证一个线程上的写入永远对于另一个线程上的不同步读取器可见。
• 即使写入可见，也不能保证它们将以预期的顺序变得可见，或者两个不同步的读取将看到不同变量的一致值。您很可能会看到 account1 的旧值和 account2 的新值，反之亦然。

Answer 3

您仅同步对变量的写访问。

因此，有可能一个线程将 account1 设置为新值，而另一个线程正在读取旧的 account2。

Answer 4

您的 Getter 未锁定。因此，即使您在更新时使用互斥体，另一个线程也会调用可以解锁运行的 Getters。

• 线程 1：
• • 更新帐户
• • • 锁定
• • • 账户1 += r
• 线程2：
• • 获取帐户1
• • 获取帐户2
• • 账户1 + 账户2 != 0
• 线程1:
• • • 帐户2 -= r
• • • 解锁

  公共 int getAccounts(){
  整数结果 = 0；
  尝试{
  互斥体.lock();
  结果=账户1+账户2；
  }catch（异常前）{
  System.out.println(ex);
  }最后{mutex.unlock();}
  返回结果；
  }