不变性是否保证线程安全？

Question

好吧，考虑下面给出的不可变类Immutable：

public final class Immutable
{
    final int x;
    final int y;
    public Immutable(int x,int y)
    {
        this.x = x;
        this.y = y;
    }
    //Setters
    public int getX()
    {
        return this.x;
    }
    public int getY()
    {
        return this.y;
    }
}

现在我在 Sharable 类中创建一个 Immutable 对象，该对象将由多个线程共享：

public class Sharable
{
    private static Immutable obj;
    public static Immutable getImmutableObject()
    {
        if (obj == null) --->(1)
        {
            synchronized(this)
            {
                if(obj == null)
                {
                    obj = new Immutable(20,30); ---> (2)
                }
            }
        }
        return obj; ---> (3)
    }
}

Thread A 将obj 视为null 并移动到同步块并创建对象。现在，由于 Java 内存模型 (JMM) 允许多个线程在对象初始化开始之后但结束之前观察对象。 因此，Thread B 可以看到对obj 的写入正在发生在写入Immutable 的字段之前。因此，Thread B 可以看到部分构造的 Immutable，它很可能处于无效状态，并且其状态可能会在以后意外更改。

这不是让Immutable 成为非线程安全的吗？

---

编辑
好的，在对 SO 进行了大量查找并彻底了解了一些 cmets 之后，我知道 您可以在线程之间安全地共享对不可变对象的引用 在构造对象后。此外，正如@Makoto 所提到的，通常需要将包含其引用的字段声明为 volatile 以确保可见性。此外，正如@PeterLawrey 所述，将对不可变对象的引用声明为final 使该字段为thread-safe

Answer 1

因此，线程 B 可以看到对 objas 的写入发生在对不可变字段的写入之前。因此，线程 B 可以看到一个部分构造的 Immutable，它很可能处于无效状态，并且其状态可能会在以后意外更改。

在 Java 1.4 中，这是真的。在 Java 5.0 及更高版本中，final 字段在构造后是线程安全的。

Answer 2

你在这里描述的是两个不同的东西。首先，Immutable 是线程安全的，如果操作是针对 it 的实例进行的。

线程安全部分是确保内存不会被另一个线程意外覆盖。就使用Immutable 而言，您永远无法覆盖它的实例中包含的任何数据，因此您可以确信，在并发环境中，当您将Immutable 对象构造到线程运行时，它将是相同的。操纵它。

你所知道的是 double-checked locking 的一个损坏的实现。

你说得对，线程 A 和线程 B 可能会在实例设置之前践踏它，从而使对象 Immutable 的整个不变性完全没有意义。

我相信解决此问题的方法是在 obj 字段中使用 volatile 关键字，以便 Java (> 1.5) 尊重单例的预期用途，并禁止线程覆盖内容obj.

现在，仔细阅读后，您会拥有一个需要两条静态数据才能存在的不可变单例，这似乎有点不可思议。这似乎更适合工厂。

public class Sharable {
    private Sharable() {
    }

    public static Immutable getImmutableInstance(int a, int b) {
        return new Immutable(a, b);
    }
}

您获得的每个Immutable 实例真正是不可变的 - 创建一个新的Immutable 对其他人没有影响，而使用Immutable 的一个实例对其他人没有任何影响也是。