不稳定的保证和无序执行

Question

重要编辑我知道“发生在”在两个作业发生的线程中我的问题是另一个线程是否可能当“a”仍然为空时读取“b”非空。所以我知道，如果您从与之前调用 setBothNonNull(...) 的线程相同的线程中调用 doIt() ，那么它不能抛出 NullPointerException。但是，如果一个线程从另一个线程调用 doIt() ，而不是调用 setBothNonNull(...) 呢？

请注意，这个问题仅与 易失性 关键字和 易失性 保证有关：它不与 synchronized 关键字相关（所以请不要回答“你必须使用同步”，因为我没有任何问题需要解决：我只是想了解关于out-of-的易失性保证（或缺乏保证）订单执行）。

假设我们有一个包含两个 volatile 字符串引用的对象，这些引用被构造函数初始化为 null，并且我们只有一种方法来修改这两个字符串：通过调用 setBoth(...)< /em> 并且我们只能在之后将它们的引用设置为非空引用（只有构造函数才允许将它们设置为空）。

例如（这只是一个例子，还没有问题）：

public class SO {

    private volatile String a;
    private volatile String b;

    public SO() {
        a = null;
        b = null;
    }

    public void setBothNonNull( @NotNull final String one, @NotNull final String two ) {
        a = one;
        b = two;
    }

    public String getA() {
        return a;
    }

    public String getB() {
        return b;
    }

}

在setBothNoNull(...)中，分配非空参数“a”的行出现在分配非空参数的行之前“b”。

然后，如果我这样做（再一次，没有问题，接下来的问题就是）：

doIt() {
    if ( so.getB() != null ) {
        System.out.println( so.getA().length );
    }
}

我的理解是否正确，由于无序执行，我可以获得 NullPointerException ？

换句话说：不能保证因为我读取了非空“b”，所以我会读取非空“a”？

因为由于乱序（多）处理器和 易失性 工作方式，“b”可以在“a”之前分配？

易失性保证写入后的读取始终会看到最后写入的值，但这里存在无序“问题”，对吗？ （再次强调，提出“问题”是为了尝试理解 volatile 关键字和 Java 内存模型的语义，而不是为了解决问题）。

Answer 1

不，您永远不会获得 NPE。这是因为易失性还具有引入先发生关系的记忆效应。换句话说，它将阻止重新排序

a = one;
b = two;

上述语句，不会被重新排序，并且所有线程都会观察 a 的值 one for a if b 已经具有值 two。

以下是大卫·霍姆斯 (David Holmes) 对此的解释：
http://markmail.org/message/j7omtqqh6ypwshfv# query:+page:1+mid:34dnnukruu23ywzy+state:results

编辑（回应后续）：
Holmes 的意思是，如果只有线程 A，编译器理论上可以进行重新排序。但是，还有其他线程，并且它们可以检测到重新排序。这就是为什么不允许编译器进行重新排序的原因。 java内存模型需要编译器专门确保没有线程会检测到这种重新排序。

但是如果有人从以下位置调用 doIt() 该怎么办？
调用线程之外的另一个线程
setBothNonNull(...) ?

不，您仍然永远不会有 NPE。易失性语义确实强加了线程间排序。这意味着，对于所有现有线程，one 的分配发生在 two 的分配之前。

Answer 2

我的理解是否正确，由于无序执行，我可以获得 NullPointerException？换句话说：不能保证因为我读取了非空“b”，所以我也会读取非空“a”？

假设分配给a和b的值或者非空，我认为你的理解不正确。 JLS 是这样说的：

(1) 如果 x 和 y 是同一线程的操作，并且 x 按程序顺序出现在 y 之前，则 hb(x, y)。

(2) 如果动作 x 与后续动作 y 同步，那么我们也有 hb(x, y)。

(3) 如果 hb(x, y) 和 hb(y, z)，则 hb(x, z)。

和

(4) 对易失性变量的写入 (§8.3.1.4) v 与 v 的所有后续读取同步由任何线程（其中后续是根据同步顺序定义的）。

定理

假设线程 #1 已调用 setBoth(...); 一次，并且参数非空，并且线程 #2 已观察到 b如果为非空，那么线程 #2 就无法观察到 a 为空。

非正式证明

1. By (1) - hb(write(a, non-null), write(b, non-null)) in thread #1
2. By ( 2) 和 (4) - hb(写(b, 非空), 读(b, 非空))
3. 通过 (1) -线程 #2 中的 hb(read(b, non-null), read(a, XXX))，
4. By (4) - hb(write(a, non-null), read(b, non-null))
5. By (4) - hb(write(a, non-null), read(a, XXX))

换句话说，将非空值写入 a “发生在”读取 a 的值 (XXX) 之前。 XXX 可以为 null 的唯一方法是，如果有其他某个操作将 null 写入 a，则 hb(write(a,non-null), write(a,XXX)) 和 hb(写（a，XXX），读（a，XXX））。根据问题定义这是不可能的，因此 XXX 不能为空。量子ED。

解释 - JLS 指出 hb(...)（“发生在之前”）关系并不完全禁止重新排序。但是，如果 hb(xx,yy)，则仅当生成的代码具有与原始序列相同的可观察效果时，才允许对操作 xx 和 yy 进行重新排序。

Answer 3

我发现下面的文章解释了在这种情况下 易失性 与同步具有相同的排序语义。 Java Volatile 很强大

Answer 4

虽然 Stephen C 的和已接受的答案很好并且几乎涵盖了它，但值得注意的是变量 a 不必是易失性的 - 并且您仍然不会得到 NPE。
这是因为，无论 a 是否为 易失性，a = one 和 b = Two 之间都会存在发生前关系。所以 Stephen C 的形式证明仍然适用，只是 a 不需要是易失性的。

Answer 5

我读了这个页面并发现了一个非- 挥发性和您的问题的非同步版本：

class Simple {
    int a = 1, b = 2;
    void to() {
        a = 3;
        b = 4;
    }
    void fro() {
        System.out.println("a= " + a + ", b=" + b);
    }
}

fro 可能会获取 1 或 3 作为 a 的值，并且独立地可能会获取 2 或 4 作为 的值b。

（我意识到这并不能回答你的问题，但它补充了你的问题。）