当数组变量是 volatile 时，我们是否需要同步对数组的访问？

Question

我有一个包含对数组的 volatile 引用的类：

private volatile Object[] objects = new Object[100];

现在，我可以保证，只有一个线程（称为writer）可以写入数组。例如，

objects[10] = new Object();

所有其他线程只会读取writer 线程写入的值。

问题：为了保证内存的一致性，我需要同步这样的读写吗？

我想，是的，我应该这样做。因为如果 JVM 在写入数组时提供某种内存一致性保证，那么从性能的角度来看，这将没有用处。但我不确定。在文档中没有发现任何有用的东西。

Answer 1

您可以使用AtomicReferenceArray:

final AtomicReferenceArray<Object> objects = new AtomicReferenceArray<>(100);

// writer
objects.set(10, new Object());

// reader
Object obj = objects.get(10);

这将确保读/写操作的原子更新和发生前的一致性，就像数组的每个项目都是volatile一样。

Answer 2

private volatile Object[] objects = new Object[100];

这样，您只能将 objects 引用设为 volatile。不是关联的数组实例内容。

问题：为了保证内存的一致性，是否需要同步这样的读写？

是的。

如果 JVM 在写入数组时提供某种内存一致性保证，从性能的角度来看，这将没有用

考虑使用 CopyOnWriteArrayList 之类的集合（或您自己的数组包装器，在 mutators 和 read 方法中实现一些 Lock）。

Java 平台也有Vector（因设计缺陷而过时）和synchronized List（在许多情况下很慢），但我不建议使用它们。

PS： One more good idea 来自 @SashaSalauyou

Answer 3

每JLS § 17.4.5 – Happens-before Order:

两个动作可以通过 happens-before 关系进行排序。如果一个动作在另一个动作之前发生，那么第一个动作对第二个动作可见并排在第二个动作之前。

[...]

每次后续读取该字段时都会写入volatile 字段发生之前。

happens-before 关系非常强。这意味着如果线程 A 写入 volatile 变量，而任何线程 B 稍后读取该变量，则线程 B 保证可以看到 volatile 变量本身的更改，以及所有其他更改 线程 A 在设置 volatile 变量之前创建，包括任何其他对象，无论它们是否为 volatile。

然而，这还不够！

元素赋值objects[10] = new Object(); 不是变量objects 的写入。它只是读取变量以确定它指向的数组，然后写入另一个变量，该变量包含在位于内存中其他位置的数组对象中。仅通过读取volatile 变量就不会建立 happens-before 关系，因此代码是不安全的。

正如@DimitarDimitrov 指出的那样，您可以通过对objects 变量进行虚拟写入来解决这个问题。每对操作——作者线程的objects = objects;重新分配加上读者线程的foo = objects[x];查找——定义了一个更新的happens-before关系，因此将“发布”所有作者线程对读者线程所做的最新更改。这可行，但需要纪律，而且不优雅。

但是有一个更微妙的问题：即使读取线程看到数组元素的更新值仍然不能保证它正确看到该元素引用的对象的字段，因为以下可以订购：

1. Writer 创建了一些对象foo。
2. 作家集objects[x] = foo;
3. 阅读器检查objects[x] 并看到对新对象foo 的引用（它可以这样做，但不能保证这样做，因为没有happens-before 关系尚未）。
4. 作家做objects = objects;

不幸的是，这并没有定义正式的 happens-before 关系，因为 volatile 变量 read (3) 出现在 volatile 变量 write (4) 之前。虽然读者可以偶然看到objects[x] 是对象foo，但这并不意味着foo 的字段是安全发布的，因此读者理论上可能会看到新对象，但值错误！为了解决这个问题，您使用此技术在线程之间共享的对象需要具有所有字段 final 或 volatile 或以其他方式同步。如果对象都是Strings，例如，你会没事的，但否则，这太容易出错了。 _{^{（感谢@Holger 指出这一点。）}}

---

这里有一些不那么不稳定的替代品：

• 像AtomicReferenceArray 这样的并发数组类的存在是为了提供数组，其中每个元素 的行为就像volatile。这更容易正确使用，因为它确保如果读取器看到更新后的数组元素值，它也会正确地看到该元素引用的对象。

• 您可以将所有对数组的访问包装在synchronized 块中，在某个共享对象上同步：

  // writer
  synchronized (aSharedObject) {
      objects[x] = foo;
  }
  

  // reader
  synchronized (aSharedObject) {
      bar = objects[x];
  }
  

  与volatile 一样，使用synchronized 会创建happens-before 关系。 （线程在释放对象的同步锁之前所做的一切在任何其他线程获取同一对象的同步锁之前发生。）如果你这样做，你的数组不需要是@987654355 @。

• 考虑一下数组是否真的是你需要的。您还没有说这些编写器和读取器线程的用途，但是如果您想要某种生产者-消费者队列，那么您真正需要的类是BlockingQueue 或Executor。您应该查看 Java 并发类，看​​看其中一个是否已经满足您的需求，因为如果有，它肯定比volatile 更容易正确使用。

Answer 4

是的，您需要同步对 volatile 数组元素的访问。

其他人已经讨论了如何使用CopyOnWriteArrayList 或AtomicReferenceArray 来代替，所以我将转向一个稍微不同的方向。我还建议阅读 JMM 的主要贡献者之一杰里米·曼森 (Jeremy Manson) 的 Volatile Arrays in Java。

现在，我可以保证只有一个线程（称为 writer）可以写入数组，例如如下：

您是否可以提供单一作者保证与volatile 关键字没有任何关系。我认为您没有想到这一点，但我只是澄清一下，以免其他读者产生错误的印象（我认为这句话可以构成数据竞赛双关语)。

所有其他线程将只读取写入器线程写入的值。

是的，但是就像您的直觉正确引导您一样，这仅适用于对数组的引用的值。 这意味着除非您正在编写对 volatile 变量的数组引用，否则您将无法获得 volatile 写入-读取合约的写入部分。

这意味着要么你想做类似的事情

objects[i] = newObj;
objects = objects;

这在许多方面都是丑陋和可怕的。 或者您想在每次编写器进行更新时发布一个全新的数组，例如

Object[] newObjects = new Object[100];

// populate values in newObjects, make sure that newObjects IS NOT published yet

// publish newObjects through the volatile variable
objects = newObjects;

这不是一个很常见的用例。

请注意，与不提供volatile-write 语义的设置数组元素不同，获取数组元素（使用newObj = objects[i];）确实提供volatile-read 语义，因为您正在取消引用数组:)

因为从性能的角度来看，如果 JVM 在写入数组时提供某种内存一致性保证，这将无用。但我不确定。

正如您所暗示的那样，确保volatile 语义所需的内存隔离将非常昂贵，如果您将虚假共享添加到混合中，情况会变得更糟。

在文档中没有找到任何有用的东西。

您可以放心地假设数组引用的volatile 语义与非数组引用的volatile 语义完全相同，考虑到数组（甚至是原始数组）仍然存在，这一点也不奇怪对象。