通过引用延迟初始化的非易失性字符串进行访问是线程安全的吗？

Question

我有一个String 字段，它被初始化为null，但随后可能被多个线程访问。该值将在首次访问时延迟初始化为幂等计算值。

这个字段是否需要volatile 才能保证线程安全？

这是一个例子。

public class Foo {
    private final String source;
    private String BAR = null;

    public Foo(String source) {
        this.source = source;
    }

    private final String getBar() {
        String bar = this.BAR;
        if (bar == null) {
            bar = calculateHashDigest(source); // e.g. an sha256 hash
            this.BAR = bar;
        }
        return bar;
    }

    public static void main(String[] args) {
        Foo foo = new Foo("Hello World!");
        new Thread(() -> System.out.println(foo.getBar())).start();
        new Thread(() -> System.out.println(foo.getBar())).start();
    }
}

我以System.out.println() 为例，但我并不担心当它的调用被互锁时会发生什么。 （虽然我很确定这也是线程安全的。）

BAR 必须是volatile 吗？

我认为答案是 否，volatile 不是必需的，是它是线程安全的，主要是因为 excerpt from JLS 17.5：

final 字段还允许程序员在不同步的情况下实现线程安全的不可变对象。线程安全的不可变对象被所有线程视为不可变对象，即使使用数据竞争在线程之间传递对不可变对象的引用也是如此。

因为String 的char value[] 字段确实是final。

（int hash 不是 final，但它的惰性初始化看起来也不错。）

编辑：编辑以澄清用于BAR 的值是固定 值。它的计算是幂等的，没有副作用。我不介意计算是否跨线程重复，或者BAR 由于内存缓存/可见性而成为有效的线程本地。我担心的是，如果它不是 null，那么它的值是完整的，而不是部分的。

Answer 1

您的代码（技术上）不是线程安全的。

String 确实是一个正确实现的不可变类型，你所说的关于它的 final 字段的事情是正确的。但这不是线程安全问题的所在。

第一个问题是BAR 的延迟初始化存在竞态条件。如果两个线程同时调用getBar()，它们都会将BAR 视为null，然后都尝试对其进行初始化。

第二个问题是存在内存风险。由于一个线程对BAR 的写入与另一个线程对BAR 的后续读取之间没有happens-before 关系，因此无法保证第二个线程将看到BAR 的初始化值.因此，它可能会重复初始化。

请注意，在示例中如前所述，这两个问题不是实际的线程安全问题。您正在执行的初始化是幂等。这对您可能多次初始化BAR 的代码行为没有影响，因为您总是将其初始化为对同一String 对象的引用。 （单个冗余初始化的成本太小，无需担心。）

但是，如果BAR 是对可变对象的引用，或者如果初始化开销很大，那么这就是一个真正的线程安全问题。

正如@Ravindra 所说，简单的解决方案是将getBar 声明为synchronized。这解决了这两个问题。

您声明BAR 的想法解决了内存风险问题，而不是竞争条件。

---

您在问题中添加了以下内容：

编辑以阐明用于BAR 的值是固定值。它的计算是幂等的，没有副作用。我不介意计算是否跨线程重复，或者BAR 由于内存缓存/可见性而成为有效的线程本地。我担心的是，如果它不是 null，那么它的值是完整的，而不是部分的。

这并没有改变我上面所说的。如果值为String，那么它是一个正确实现的不可变对象，您将总是看到一个完整的值不管其他任何东西。这就是 JLS 的名言！

^{（实际上，我忽略了String 使用非final 字段来保存延迟计算的哈希码的细节。但是，String::hashCode 实现会处理这个问题。没有线程- 安全问题。如果您愿意，请自行检查。）}

Answer 2

您的代码不是线程安全的。看来您可能正在考虑双重检查锁定模式。正确的模式是这样的：

public class Foo {

    private static volatile String BAR = null;

    private static String getBar() {
        String bar = BAR;
        if (bar == null) {
          synchronized( Foo.class )
            if( bar == null ) {
              bar = "Hello World!";
              BAR = bar;
            }
        }
        return bar;
    }
    // ...

这里有两件事。

1. 如果 BAR 已初始化，则不会进入 synchronized 块。 volatile 在这里是必要的，因为需要进行一些同步，并且 BAR 的读取将与对 volatile BAR 的写入同步。

1234563如果我们不进行原子检查，那么BAR 可能会被多次初始化。

您引用了 Java 规范。关于final 关键字。虽然String 是不可变的并且在内部使用final 关键字，但这不会影响您的字段BAR。字符串很好，但是您的字段仍然是共享内存位置，如果您希望它是线程安全的，则需要对其进行同步。

另一张海报也提到了实习字符串。他们正确地说，在这个特定的实例中，将只有一个 "Hello World!" 对象，因为 JVM 规范保证字符串是被实习的。这是一种奇怪的线程安全形式，对其他对象不起作用，所以只有在确定它可以正常工作时才使用它。您自己创建的大多数对象将无法像现在一样使用您拥有的代码。

最后我想我要指出，因为"Hello World!" 已经是一个字符串对象，所以尝试“延迟加载”它没有多大意义。字符串是在加载类时由 JVM 创建的，因此它们在运行方法时已经存在，甚至在第一次读取 BAR 时已经存在。在这种情况下，只有一个字符串，尝试“延迟加载”字符串没有任何优势。

public class Foo {

    //  probably better, simpler
    private static final String BAR = "Hello World!";