Java - 不可变数组线程安全

Question

我有一个关于 Java 内存模型的问题。这是一个提出问题的简单类：

public class ImmutableIntArray {

    private final int[] array;

    public ImmutableIntArray() {
        array = new int[10];
        for (int i = 0; i < 10; i++) {
            array[i] = i;
        }
    }

    // Will always return the correct value?
    public int get(int index) {
        return array[index];
    }

}

据我所知，JMM 保证最终字段的值在构造后对其他线程可见。但我想确保其他线程在构造后会看到数组中存储的最新版本的数据。

当然，上面的代码只是一个简单的示例来说明问题，实际上我想为直接字节缓冲区实现一个简单的缓存，并且我不想依赖某些 Collection 类。目前我正在使用 ReentrantReadWriteLock 来确保正确的行为，但如果可能的话我希望避免它。

Answer 1

在这个例子中，一切都会好起来的（嗯，让我们暂停一下判断）。当谈到线程安全时，不变性是一种美味——如果一个值不能改变，大多数并发问题就不再是一个问题。

Amir 提到 volatile 这通常很有用 - 但构造函数也有类似的语义 < code>final 确保可见性的变量。请参阅 JLS 条款 17.5详细信息 - 本质上，构造函数在最终变量的写入和任何后续读取之间形成了发生之前关系。

编辑：因此，您在构造函数中设置了对数组的values引用，此时它在所有线程中都是可见的，然后它就不会改变。所以我们知道所有其他线程都会看到相同的数组。但是数组的内容呢？

就目前情况而言，数组元素在波动性方面没有任何特殊语义，它们就像您自己声明了一个类一样：

public class ArrayTen {
    private int _0;
    private int _1;
    // ...
    private int _9;

    public int get(int index) {
       if (index == 0) return _0;
       // etc.
    }
}

所以 - 如果我们可以做一些事情来建立<，另一个线程只会看到这些变量em>发生在之前的关系。如果我的理解是正确的，这只需要对您的原始代码进行很小的更改。

我们已经知道数组引用的设置发生在构造函数结束之前。始终正确的另一点是，一个线程中的操作发生在同一线程中的后续操作之前。因此，我们可以通过先设置数组字段，然后分配最终字段来组合这些，从而获得可见性的传递保证。这当然需要一个临时变量：

public class ImmutableIntArray {

    private final int[] array;

    public ImmutableIntArray() {
        int[] tmp = new int[10];
        for (int i = 0; i < 10; i++) {
            tmp[i] = i;
        }
        array = tmp;
    }

    // get() etc.
}

我认为这保证是安全的，因为我们已经改变了看似不相关的分配和填充顺序。

但同样，我可能还遗漏了其他一些东西，这意味着并发保证并不像希望的那么强大。在我看来，这个问题是一个很好的例子，说明了为什么编写防弹多线程代码很棘手，即使您认为自己正在做一些非常简单的事情，以及如何需要大量的思考和谨慎（然后是错误修复）才能正确。

Answer 2

你的例子不太正确。为了获得最终的现场保证，您需要：

public ImmutableIntArray() {
    int tmparray = new int[10];
    for (int i = 0; i < 10; i++) {
        tmparray[i] = i;
    }
    array = tmparray;
}

Answer 3

我确实认为数组的语义与对象的最终引用相同。规范规定

只有在对象完全初始化后才能看到对该对象的引用的线程保证看到该对象的最终字段的正确初始化值。

它还说

它还将看到这些最终字段引用的任何对象或数组的版本，这些版本至少与最终字段一样最新。

http://java.sun.com/docs/books /jls/third_edition/html/memory.html#17.5

Answer 4

我认为你的数组更改将通过 ImmutableIntArray 可见。
根据我对 JLS 的阅读，[freeze] 操作应该在构造函数退出时发生。
我认为使用临时数组是没有用的：

int tmparray = new int[10];
for (int i = 0; i < 10; i++) {
    tmparray[i] = i;
}
array = tmparray;

为了获得最终的字段保证，我们需要在构造函数退出之前的某个地方使用 [freeze]：

int tmparray = new int[10];
for (int i = 0; i < 10; i++) {
    tmparray[i] = i;
}
array = tmparray;
[freeze]

无论如何，[freeze] 都会打开大门以重新排序其上方的指令，因此我们将得到相同的东西：

int tmparray = new int[10];
array = tmparray; 
for (int i = 0; i < 10; i++) {
    tmparray[i] = i;
}
[freeze]

[freeze] 的实现至少包含一个 [StoreStore]。此 [StoreStore] 屏障必须在发布构造的实例之前发出。

来自JSR-133 Cookbook：

您不能将构造函数内的final存储移至构造函数外部的存储下方，这可能会使对象对其他线程可见。 （如下所示，这可能还需要发出障碍）。同样，您不能使用第三个分配对前两个分配中的任何一个进行重新排序：
v.afield = 1； x.finalField = v; ...;共享引用 = x;

我认为这是由
（JSR-133 食谱）：

在所有存储之后但在从具有最终字段的任何类的任何构造函数返回之前发出 StoreStore 屏障。

因此，在所有其他构造函数存储完成之前，我们无法将其存储在sharedRef中。

您可以通过以下方式搜索：(JSR133规格）。