java：关于不可变和最终的问题

Question

我正在读《Effective Java》一书。

在“最小化可变性”一文中，Joshua Bloch 谈到了使类变得不可变。

1. 不要提供任何修改对象状态的方法 - 这很好。

2. 确保该类无法扩展。 - 我们真的需要这样做吗？

3. 将所有字段设为最终值 - 我们真的需要这样做吗？

例如，假设我有一个不可变的类，

class A{
private int a;

public A(int a){
    this.a =a ;
}

public int getA(){
    return a;
}
}

从 A 扩展的类如何损害 A 的不可变性？

Answer 1

像这样：

public class B extends A {
    private int b;

    public B() {
        super(0);
    }

    @Override
    public int getA() {
        return b++;
    }
}

从技术上讲，您不会修改从 A 继承的字段，但在不可变对象中，重复调用同一 getter 当然会产生相同的数字，但事实并非如此这里。

当然，如果您坚持规则#1，则不允许您创建此覆盖。但是，您不能确定其他人会遵守该规则。如果您的方法之一采用 A 作为参数并对其调用 getA()，则其他人可能会像上面那样创建类 B 并将其实例传递给您的方法；然后，您的方法将在不知情的情况下修改该对象。

Answer 2

里氏替换原则指出，子类可以在超类所在的任何地方使用。从客户的角度来看，孩子就是父母。

因此，如果您重写子级中的方法并使其可变，那么您就违反了与希望该方法不可变的父级客户端之间的合同。

Answer 3

如果您将一个字段声明为final，则尝试修改该字段或使其保持未初始化状态不仅仅是使其成为编译时错误。

在多线程代码中，如果您与数据竞争共享类 A 的实例（即，没有任何类型的同步，即通过将其存储在全局可用的位置，例如静态字段），某些线程可能会看到 getA() 的值发生变化！

Final 字段得到保证（通过 JVM 规范）使其值对所有线程可见构造函数完成后，即使没有同步。

考虑这两个类：

final class A {
  private final int x;
  A(int x) { this.x = x; }
  public getX() { return x; }
}

final class B {
  private int x;
  B(int x) { this.x = x; }
  public getX() { return x; }
}

A 和 B 都是不可变的，也就是说您无法在初始化后修改字段 x 的值（让我们忘记反思）。唯一的区别是 A 中的字段 x 被标记为 final。您很快就会意识到这一微小差异的巨大影响。

现在考虑下面的代码：

class Main {
  static A a = null;
  static B b = null;
  public static void main(String[] args) {
    new Thread(new Runnable() { void run() { try {
      while (a == null) Thread.sleep(50);
      System.out.println(a.getX()); } catch (Throwable t) {}
    }}).start()
    new Thread(new Runnable() { void run() { try {
      while (b == null) Thread.sleep(50);
      System.out.println(b.getX()); } catch (Throwable t) {}
    }}).start()
    a = new A(1); b = new B(1);
  }
}

假设两个线程碰巧发现它们正在监视的字段在主线程设置它们后不为空（请注意，虽然这个假设可能看起来微不足道，但 JVM 不能保证！）。

在这种情况下，我们可以确定监视 a 的线程将打印值 1，因为它的 x 字段是最终的 - 所以，构造函数完成后，可以保证所有看到该对象的线程都会看到 x 的正确值。

但是，我们无法确定另一个线程会做什么。规范只能保证它将打印 0 或 1。由于该字段不是 final，并且我们没有使用任何类型的同步（synchronized 或 易失性），因此线程可能会看到该字段未初始化并打印 0！另一种可能性是它实际上看到该字段已初始化，并打印 1。它无法打印任何其他值。

另外，可能发生的情况是，如果您继续读取并打印 b 的 getX() 值，它可能会在之后开始打印 1打印 0 一会儿！在这种情况下，很清楚为什么不可变对象必须有其字段final：从第二个线程的角度来看，b已经改变，即使它应该改变通过不提供设置器来实现不可变！

如果您想保证第二个线程将看到 x 的正确值而不将字段设为 final，您可以声明保存 B 实例的字段 易失性：

class Main {
  // ...
  volatile static B b;
  // ...
}

另一种可能是在设置和读取字段时进行同步，可以通过修改类 B:

final class B {
  private int x;
  private synchronized setX(int x) { this.x = x; }
  public synchronized getX() { return x; }
  B(int x) { setX(x); }
}

或修改 Main 的代码，在字段 b 为时添加同步读取和写入——请注意，这两个操作必须在同一个对象上同步！

正如您所看到的，最优雅、可靠和高性能的解决方案是将字段 x 设为最终字段。

---

最后要注意的是，对于不可变的线程安全类来说，并非绝对有必要将其所有字段都设为final。然而，这些类（线程安全、不可变、包含非最终字段）必须非常小心地设计，并且应该留给专家。

java.lang.String 类就是一个例子。它有一个 private int hash; 字段，该字段不是最终的，用作 hashCode() 的缓存：

private int hash;
public int hashCode() {
  int h = hash;
  int len = count;
  if (h == 0 && len > 0) {
    int off = offset;
    char val[] = value;
    for (int i = 0; i < len; i++)
      h = 31*h + val[off++];
    hash = h;
  }
  return h;
}

如您所见，hashCode() 方法首先读取（非最终的） ) 字段哈希。如果它未初始化（即，如果它是0），它将重新计算它的值，并设置它。对于计算了哈希码并写入该字段的线程，它将永远保留该值。

但是，其他线程可能仍会看到该字段为 0，即使线程已将其设置为其他值之后也是如此。在这种情况下，这些其他线程将重新计算哈希值，并获得完全相同的值，然后对其进行设置。

在这里，证明该类的不变性和线程安全性的理由是，每个线程都将获得完全相同的 hashCode() 值，即使它被缓存在非最终字段中，因为它将被重新计算并获得完全相同的值将获得。

所有这些推理都非常微妙，这就是为什么建议在不可变的线程安全类上将所有字段标记为final。

Answer 4

如果扩展类，则派生类可能不是不可变的。

如果您的类是不可变的，那么所有字段在创建后都不会被修改。 Final 关键字将强制执行这一点，并使未来的维护者显而易见。

Answer 5

添加此答案以指向 确切的答案JVM 规范的部分提到了为什么成员变量需要是最终的才能在不可变类中实现线程安全。这是规范中使用的示例，我认为非常清楚：

class FinalFieldExample { 
    final int x;
    int y; 
    static FinalFieldExample f;

    public FinalFieldExample() {
        x = 3; 
        y = 4; 
    } 

    static void writer() {
        f = new FinalFieldExample();
    } 

    static void reader() {
        if (f != null) {
            int i = f.x;  // guaranteed to see 3  
            int j = f.y;  // could see 0
        } 
    } 
}

同样，来自规范：

类 FinalFieldExample 有一个最终 int 字段 x 和一个非最终 int 字段 y。一个线程可能执行方法编写器，另一个线程可能执行方法读取器。

因为 writer 方法在对象的构造函数完成后写入 f，所以 reader 方法将保证看到 fx 的正确初始化值：它将读取值 3。但是，fy 不是最终的；因此，不能保证 reader 方法看到它的值 4。