这个java类线程安全吗？

Question

这不是家庭作业对我来说，这是一些大学给学生的任务。出于个人兴趣，我对解决方案感兴趣。

任务是创建一个包含整数的类（Calc）。 add 和 mul 这两个方法应该与这个整数相加或相乘。

同时设置两个线程。一个线程应该调用 c.add(3) 十次，另一个线程应该调用 c.mul(3) 十次（当然是在同一个 Calc 对象上）。

Calc 类应确保操作交替完成（add、mul、add、mul、add、mul、..）。

我没有经常处理与并发相关的问题 - 更不用说 Java。我为 Calc 提出了以下实现：

class Calc{

    private int sum = 0;
    //Is volatile actually needed? Or is bool atomic by default? Or it's read operation, at least.
    private volatile bool b = true;

    public void add(int i){
        while(!b){}
        synchronized(this){
                sum += i;
            b = true;   
        }
    }

    public void mul(int i){
        while(b){}
        synchronized(this){
            sum *= i;
            b = false;  
        }
    }

}

我想知道我是否在正确的轨道上。 while(b) 部分肯定有更优雅的方式。 我想听听你们的想法。

PS：方法的签名不得更改。除此之外，我不受限制。

Answer 1

尝试使用 Lock 界面：

class Calc {

    private int sum = 0;
    final Lock lock = new ReentrantLock();
    final Condition addition  = lock.newCondition(); 
    final Condition multiplication  = lock.newCondition(); 

    public void add(int i){

        lock.lock();
        try {
            if(sum != 0) {
                multiplication.await();
            }
            sum += i;
            addition.signal(); 

        } 
        finally {
           lock.unlock();
        }
    }

    public void mul(int i){
        lock.lock();
        try {
            addition.await();
            sum *= i;
            multiplication.signal(); 

        } finally {
           lock.unlock();
        }
    }
}

锁的工作方式类似于您的同步块。但是如果另一个线程持有lock，这些方法将在.await() 等待，直到调用.signal()。

Answer 2

您所做的是一个繁忙的循环：您正在运行一个仅在变量更改时才停止的循环。这是一种糟糕的技术，因为它会使 CPU 非常忙碌，而不是简单地让线程等待标志更改。

我会使用两个semaphores：一个用于multiply，一个用于add。 add 必须在添加前获得addSemaphore，并在完成后向multiplySemaphore 释放许可，反之亦然。

private Semaphore addSemaphore = new Semaphore(1);
private Semaphore multiplySemaphore = new Semaphore(0);

public void add(int i) {
    try {
        addSemaphore.acquire();
        sum += i;
        multiplySemaphore.release();
    }
    catch (InterrupedException e) {
        Thread.currentThread().interrupt();
    }
}

public void mul(int i) {
    try {
        multiplySemaphore.acquire();
        sum *= i;
        addSemaphore.release();
    }
    catch (InterrupedException e) {
        Thread.currentThread().interrupt();
    }
}

Answer 3

正如其他人所说，您的解决方案中的volatile 是必需的。此外，您的解决方案会出现旋转等待，这会浪费大量 CPU 周期。也就是说，就正确性而言，我看不出有任何问题。

我个人会用一对信号量来实现这一点：

private final Semaphore semAdd = new Semaphore(1);
private final Semaphore semMul = new Semaphore(0);
private int sum = 0;

public void add(int i) throws InterruptedException {
    semAdd.acquire();
    sum += i;
    semMul.release();
}

public void mul(int i) throws InterruptedException {
    semMul.acquire();
    sum *= i;
    semAdd.release();
}

Answer 4

需要volatile，否则优化器可能会将循环优化为if(b)while(true){}

但您可以使用 wait 和 notify 来做到这一点

public void add(int i){

    synchronized(this){
        while(!b){try{wait();}catch(InterruptedException e){}}//swallowing is not recommended log or reset the flag
            sum += i;
        b = true;   
        notify();
    }
}

public void mul(int i){
    synchronized(this){
        while(b){try{wait();}catch(InterruptedException e){}}
        sum *= i;
        b = false;  
        notify();
    }
}

但是在这种情况下（b 在同步块内检查）不需要 volatile

Answer 5

是的，volatile 是必需的，不是因为从 boolean 到另一个的赋值不是原子的，而是为了防止缓存变量，使其更新的值对正在读取它的其他线程不可见.如果您关心最终结果，sum 也应该是 volatile。

话虽如此，使用wait 和notify 来创建这种交错效果可能会更优雅。

class Calc{

    private int sum = 0;
    private Object event1 = new Object();
    private Object event2 = new Object();

    public void initiate() {
        synchronized(event1){
           event1.notify();
        }
    }

    public void add(int i){
        synchronized(event1) {
           event1.wait();
        }
        sum += i;
        synchronized(event2){
           event2.notify();
        }
    }

    public void mul(int i){
        synchronized(event2) {
           event2.wait();
        }
        sum *= i;
        synchronized(event1){
           event1.notify();
        }
    }
}

然后在你启动两个线程后，调用initiate释放第一个线程。

Answer 6

嗯。您的解决方案存在许多问题。首先， volatile 不是原子性所必需的，而是可见性所必需的。我不会在这里讨论这个，但你可以阅读更多关于Java memory model 的信息。 （是的，布尔值是原子的，但在这里无关紧要）。此外，如果您仅在同步块中访问变量，则它们不必是易失性的。

现在，我假设这是偶然的，但是您的 b 变量不仅在同步块内被访问，而且它恰好是易失性的，所以实际上您的解决方案可以工作，但它既不惯用也不推荐，因为您正在等待对于 b 在繁忙的循环中进行更改。你白白浪费了 CPU 周期（这就是我们所说的自旋锁，有时它可能很有用）。

惯用的解决方案如下所示：

class Code {
    private int sum = 0;
    private boolean nextAdd = true;

    public synchronized void add(int i) throws InterruptedException {
        while(!nextAdd )
            wait();
        sum += i;
        nextAdd = false;
        notify();
    }

    public synchronized void mul(int i) throws InterruptedException {
        while(nextAdd)
            wait();
        sum *= i;
        nextAdd = true;
        notify();
    }
}

Answer 7

程序是完全线程安全的：

1. 布尔标志设置为 volatile，因此 JVM 知道不缓存值并一次保持对一个线程的写访问。

2. 两个临界区锁定当前对象，这意味着一次只有一个线程可以访问。请注意，如果一个线程在同步块内，则没有线程可以在任何其他临界区。

以上将适用于类的每个实例。例如，如果创建了两个实例，线程将能够一次进入多个临界区，但每个实例、每个临界区将被限制为一个线程。那有意义吗？