使用 AtomicBoolean 而不是同步块

Question

假设我有一个 class，其中包含 2 个实例变量和以下方法（针对此问题进行了简化）：

private final Object lock = new Object();
private boolean running;

public MyClass() {
    synchronized(lock) {
        running = false;
    }
}
public void methodA() {
    synchronized(lock) {
        running = true;
    }
}
public void methodB() {
    synchronized(lock) {
        if (!running) {
            return;
        }
    }
}

我正在查看这段代码，在阅读了有关 AtomicBoolean 的内容后，我认为这里可能适合，尤其是在查看了 MyClass 构造函数和 methodA 之后。不过我不太确定methodB。

假设这些方法可以被多个线程调用，以下是线程安全的吗？:

private AtomicBoolean running;

public MyClass() {
    running = new AtomicBoolean(false);
}
public void methodA() {
    running.set(true);
}
public void methodB() {
    if (!running.get()) {
        return;
    }
}

running.get() 是否可以保证通过 running.set(true) 或 running.set(false) 从另一个线程看到更新？

Answer 1

在您的示例中，一个简单的 volatile boolean 就足够了，因为您似乎只是在执行原子操作。如果您需要 compareAndSet.

等方法，AtomicBoolean 很有用

所以在回答你的问题时，是的，当使用 volatile boolean 或 AtomicBoolean 时，其他线程将看到变量的更新。

Answer 2

是的。来自 AtomicBoolean 的 Javadoc:

A {@code boolean} value that may be updated atomically.

这意味着对 AtomicBoolean 的任何更新都是 不可分割的 。因此，我认为 AtomicBoolean 的这种使用是 线程安全的 。

您仍应考虑将 AtomicBoolean 的声明设为最终：

private final AtomicBoolean running;

Answer 3

一般来说，这些代码块对于 methodB 是不相等的，因为读取 volatile 变量不会创建同步顺序。

假设您的 class 中有一些其他字段 int x = 42，在 methodB 中更新：

public void methodB() {
    if (!running.get()) {
        return;
    }
    if (x < 50) x++; // just example
}

那么你有几个线程调用 methodB:

当使用 synchronized 关键字时，更新是安全的并且对所有线程可见。
当使用 AtomicBoolean/volatile 时，可见性被破坏

如果变量更新没有这种情况，并且任务只是保证 methodA - methodB 序列之间的可见性，那么没关系 - AtomicBoolean 就足够了。

使用 AtomicBoolean 而不是同步块

Using AtomicBoolean instead of synchronized blocks

java

multithreading

java-threads

atomicboolean