易失性布尔值与原子布尔值

Question

AtomicBoolean 能做什么是 volatile 布尔值无法实现的？

Answer 1

当所述字段仅由其所有者线程更新并且该值仅由其他线程读取时，我使用易失性字段，您可以将其视为发布/订阅场景，其中有许多观察者但只有一个发布者。然而，如果这些观察者必须根据字段的值执行一些逻辑，然后推回一个新值，那么我会使用 Atomic* vars 或锁或同步块，无论什么最适合我。在许多并发场景中，它归结为获取值，将其与另一个值进行比较，并在必要时进行更新，因此 Atomic* 类中存在compareAndSet 和 getAndSet 方法。

检查 的 JavaDocs java.util.concurrent.atomic 包，提供原子类列表以及它们如何工作的精彩解释（刚刚了解到它们是无锁的，因此它们比锁或同步块有优势）

Answer 2

他们只是完全不同。考虑一下这个易失性整数的示例：

volatile int i = 0;
void incIBy5() {
    i += 5;
}

如果两个线程同时调用该函数，则 i 之后可能为 5，因为编译后的代码将与此有些类似（除非您不能同步int）：

void incIBy5() {
    int temp;
    synchronized(i) { temp = i }
    synchronized(i) { i = temp + 5 }
}

如果变量是易失性的，则对它的每个原子访问都是同步的，但实际上什么是原子访问并不总是显而易见的。使用 Atomic* 对象，可以保证每个方法都是“原子的”。

因此，如果您使用 AtomicInteger 和 getAndAdd(int delta)，则可以确定结果将为 10。同样，如果两个线程同时对一个 boolean 变量取反，使用 AtomicBoolean 您可以确保它之后具有原始值，使用 易失性布尔值，你不能。

因此，每当您有多个线程修改某个字段时，您就需要使其原子化或使用显式同步。

易失性 的目的是不同的。考虑这个示例

volatile boolean stop = false;
void loop() {
    while (!stop) { ... }
}
void stop() { stop = true; }

如果您有一个线程正在运行 loop()，而另一个线程正在调用 stop()，那么如果您省略 volatile，您可能会遇到无限循环。 code>，因为第一个线程可能会缓存 stop 的值。在这里，易失性充当编译器在优化时更加小心的提示。

Answer 3

您不能将 compareAndSet、getAndSet 作为具有 易失性布尔值的原子操作（当然除非您同步它）。

Answer 4

AtomicBoolean 具有以原子方式执行复合操作的方法，而无需使用 synchronized 块。另一方面，如果在 synchronized 块内执行复合操作，则 volatile boolean 只能执行复合操作。

读/写 volatile boolean 的内存效果分别与 AtomicBoolean 的 get 和 set 方法相同。

例如，compareAndSet 方法将自动执行以下操作（没有 synchronized 块）：

if (value == expectedValue) {
    value = newValue;
    return true;
} else {
    return false;
}

因此，compareAndSet 方法将允许您编写以下代码：即使从多个线程调用，也保证只执行一次。例如：

final AtomicBoolean isJobDone = new AtomicBoolean(false);

...

if (isJobDone.compareAndSet(false, true)) {
    listener.notifyJobDone();
}

保证只通知监听器一次（假设在将 AtomicBoolean 设置为 true 后没有其他线程再次将其设置回 false ）。

Answer 5

Volatile 布尔值与 AtomicBoolean

Atomic* 类包装了相同类型的 volatile 原语。从源头来看：

public class AtomicLong extends Number implements java.io.Serializable {
   ...
   private volatile long value;
   ...
   public final long get() {
       return value;
   }
   ...
   public final void set(long newValue) {
       value = newValue;
   }

因此，如果您所做的只是获取和设置 Atomic* 那么您最好只拥有一个 volatile 字段。

AtomicBoolean 能做什么是 volatile 布尔值无法实现的？

Atomic* 类为您提供了提供更高级功能的方法，例如用于数字的 incrementAndGet()、用于布尔值的 compareAndSet() 以及实现多个操作（获取/增量）的其他方法。 /设置，测试/设置），无需锁定。这就是 Atomic* 类如此强大的原因。

例如，如果多个线程使用 ++ 使用以下代码，则会出现竞争条件，因为 ++ 实际上是：get、increment 和 set。

private volatile value;
...
// race conditions here
value++;

但是，以下代码将在没有锁的情况下安全地在多线程环境中工作：

private final AtomicLong value = new AtomicLong();
...
value.incrementAndGet();

还需要注意的是，使用 Atomic* 类包装 易失性字段是从对象角度封装关键共享资源的好方法。这意味着开发人员不能只处理该字段，假设该字段不共享，可能会导致字段++出现注入问题；或其他引入竞争条件的代码。

Answer 6

volatile 关键字保证共享该变量的线程之间发生先发生关系。它不能保证 2 个或更多线程在访问该布尔变量时不会互相中断。

Answer 7

这里的很多答案都过于复杂、令人困惑，或者根本就是错误的。例如：

...如果您有多个线程修改布尔值，则应该使用 AtomicBoolean。

作为一般性陈述，这是不正确的。

如果变量是易失性的，则对它的每个原子访问都是同步的......

这是不正确的；同步是完全不同的事情。

简单的答案是，AtomicBoolean 允许您防止某些操作中的竞争条件，这些操作需要读取值，然后根据您读取的内容写入一个值；它使此类操作成为原子操作（即，它消除了变量在读取和写入之间可能发生变化的竞争条件）——因此得名。

如果您只是读取和写入变量，其中写入不依赖于您刚刚读取的值，那么即使使用多个线程，易失性也可以正常工作。

Answer 8

记住惯用语 -

读 - 修改 - 写，这是你无法用 volatile 实现的

Answer 9

如果有多个线程访问类级别变量那么
每个线程都可以在其线程本地缓存中保留该变量的副本。

使变量可变将阻止线程将变量的副本保留在线程本地缓存中。

原子变量是不同的，它们允许对其值进行原子修改。

Answer 10

如果只有一个线程修改布尔值，则可以使用易失性布尔值（通常这样做是为了定义在线程的主循环中检查的stop变量）。

但是，如果您有多个线程修改布尔值，则应使用 AtomicBoolean。否则，下面的代码是不安全的：

boolean r = !myVolatileBoolean;

该操作分两步完成：

1. 读取布尔值。
2. 布尔值被写入。

如果其他线程修改 #1 和 2# 之间的值，您可能会得到错误的结果。 AtomicBoolean 方法通过原子地执行步骤 #1 和 #2 来避免此问题。

Answer 11

Boolean 原始类型对于写入和读取操作是原子的，易失性保证了happens-before 原则。因此，如果您需要简单的 get() 和 set()，那么您不需要 AtomicBoolean。

另一方面，如果您需要在设置变量的值之前进行一些检查，例如“如果为 true，则设置为 false”，那么您也需要以原子方式执行此操作，在这种情况下，请使用compareAndSet 和由AtomicBoolean，因为如果您尝试使用易失性布尔值实现此逻辑，您将需要一些同步以确保该值在 get 和 set 之间没有更改。

Answer 12

两者具有相同的概念，但在原子布尔中，它将为操作提供原子性，以防 cpu 切换发生在两者之间。