如果您将一个字段声明为
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 字段是 final 的——因此，在构造函数完成后，保证所有看到该对象的线程都将看到
x 的正确值。
然而，我们不能确定另一个线程会做什么。规范只能保证它将打印
0 或
1。由于该字段不是
final，并且我们没有使用任何类型的同步（
synchronized 或
volatile），该线程可能会看到未初始化的字段并打印 0！另一种可能性是它实际上看到了初始化的字段，并打印 1。它无法打印任何其他值。
此外，如果您继续读取和打印
b 的
getX() 值，它可能会在打印了一段时间的 0 后开始打印 1！在这种情况下，很明显为什么不可变对象必须具有其字段
final：从第二个线程的角度来看，即使不提供设置器，
b 已经改变了！
如果您想保证第二个线程在不将字段设为
final 的情况下看到正确的
x 值，则可以将保存
B 实例的字段声明为 volatile。
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。
最后需要注意的是，不是绝对必要的，线程安全的不可变类必须将所有字段都设置为final。然而，这些类（线程安全、不可变、包含非final字段）必须经过精心设计，并应该留给专家处理。
java.lang.String类就是一个例子。它有一个私有的int类型的hash字段，该字段不是final，并用作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()方法首先读取（非final）字段hash。如果它未初始化（即为0），则会重新计算其值并设置它。对于计算哈希码并写入该字段的线程，它将永久保留该值。
然而，其他线程可能仍然看到该字段的值为0，即使某个线程已将其设置为其他值。在这种情况下，这些其他线程将重新计算哈希值，并获得完全相同的值，然后设置它。
这里，证明了类的不可变性和线程安全性，因为每个线程将获得完全相同的hashCode()值，即使它被缓存在非final字段中，因为它将被重新计算，并获得完全相同的值。
所有这些推理都非常微妙，这就是为什么建议在不可变的、线程安全的类上标记所有字段为final的原因。
