本文深入探讨java中线程如何与对象交互，特别是对共享对象引用的理解以及java内存模型（jmm）在多线程环境下的作用。文章将澄清对象引用与对象实例的区别，解释cpu缓存机制如何导致数据竞争，并介绍“happens-before”原则及其实现方式，旨在帮助开发者构建健壮的并发应用。
在Java并发编程中，理解线程如何访问和操作对象是至关重要的。许多初学者可能会对一个线程在无限循环中运行时，另一个线程仍能调用该线程中声明的对象的某个方法感到困惑。这种困惑通常源于对Java中“对象引用”与“对象实例”之间关系的误解，以及对Java内存模型（JMM）工作原理的不熟悉。
理解对象引用与对象实例
首先，我们需要明确Java中对象引用（Reference Variable）和实际对象实例（Object Instance）之间的根本区别。当我们在代码中声明一个变量并使用new关键字创建对象时，例如：
whatTime wt = new whatTime();
这里发生了两件不同的事情：
- 声明引用变量：whatTime wt 在当前线程的栈空间中声明了一个名为 wt 的引用变量。这个变量存储的不是 whatTime 对象本身，而是一个指向堆内存中 whatTime 对象的“地址”。可以将其类比为地址簿中的一页，上面记录着一栋房子的地址。
- 创建对象实例：new whatTime() 在Java堆内存中创建了一个 whatTime 类的实际实例。这就像是“建造”了一栋房子。
因此，wt 变量本身只是一个地址，而真正的 whatTime 对象则存在于堆中。栈空间是线程私有的，当方法返回时，栈帧会被立即回收，其他线程无法直接访问。然而，堆内存是所有线程共享的。
立即学习“Java免费学习笔记（深入）”；
线程如何共享对象
当我们将一个对象的引用传递给另一个线程时，例如：
threadA ta = new threadA(wt); ta.start();
这里，threadA 的构造函数接收了 wt 的一个副本。这意味着 mainClass 中的 wt 引用和 threadA 中的 wt 引用（通过构造函数参数传递给其内部字段）都指向堆内存中的同一个 whatTime 对象实例。就像你和朋友都有一份地址簿，上面记录着同一栋房子的地址。你们各自的地址簿是独立的，但如果你们都根据地址去访问那栋房子，那么你们看到的就是同一栋房子，并且任何一方对房子的修改（比如砸碎窗户），另一方也能观察到。
因此，即使 mainClass 的 main 方法进入 while(true) 循环，threadA 仍然持有 whatTime 对象的引用，并可以通过这个引用调用 whatTime 对象的方法，因为它们操作的是堆中同一个对象实例。while(true) 循环本身并不阻止其他线程与共享对象进行交互，它仅仅表示当前线程正在执行一个耗时操作。
Java内存模型与数据竞争
“一个线程在while(true)循环中，其他线程无法与之交互”这种说法，更准确的理解应该是：如果多个线程同时访问并修改同一个共享的可变状态（字段），而没有采取适当的同步措施，就可能导致数据竞争（Data Race），进而产生不可预测的结果。这涉及到Java内存模型（JMM）的核心概念。
现代CPU为了提高性能，通常不会直接读写主内存。它们拥有自己的高速缓存（L1、L2、L3 Cache），数据在CPU核心的缓存和主内存之间同步。JMM允许Java虚拟机（JVM）和编译器进行指令重排序和本地缓存优化，这意味着：
- 一个线程对共享变量的修改可能首先写入其CPU缓存，而不是立即写入主内存。
- 另一个线程在读取该共享变量时，可能从自己的CPU缓存中读取到旧值，而不是主内存中的最新值。
这种缓存不一致性是导致多线程程序中出现意外行为的根本原因。
考虑以下示例，它展示了一个典型的数据竞争问题：
class Example {
int x; // 共享的可变状态
void crazy() {
x = 1;
new Thread(() -> x = 5).start(); // 线程1修改 x
new Thread(() -> x = 10).start(); // 线程2修改 x
System.out.println(x); // 主线程读取 x
}
}在上述代码中，x 是一个共享的可变字段。两个新线程并发地修改 x 的值，而主线程在它们启动后立即打印 x。由于缺乏同步，JMM不保证这些操作的顺序和可见性。因此，System.out.println(x) 的输出可能是 1、5 或 10，甚至在不同的运行环境、JVM版本或硬件架构下，结果都可能不同。这种行为是合法的，因为JMM允许这种不确定性，除非通过特定的机制建立“Happens-Before”关系。
Happens-Before 原则
为了解决数据竞争和内存可见性问题，JMM引入了“Happens-Before”原则。如果操作A Happens-Before 操作B，那么操作A的结果对操作B是可见的，并且操作A及其之前的内存写入操作，都会在操作B及其之后的内存读取操作之前完成。
建立Happens-Before关系可以通过以下几种方式：
- synchronized 关键字：对同一个锁的解锁操作 Happens-Before 后续对该锁的加锁操作。
- volatile 关键字：对 volatile 变量的写入操作 Happens-Before 后续对该变量的读取操作。
- Thread.start()：一个线程的 start() 方法 Happens-Before 该线程中的任何操作。
- Thread.join()：一个线程的 join() 方法 Happens-Before 另一个线程中所有依赖于被 join 线程的操作。
- 标准库中的并发工具：java.util.concurrent 包中的类（如 ConcurrentHashMap、AtomicInteger 等）内部已经处理了Happens-Before关系。
原始代码分析
回到最初的示例代码：
public class mainClass {
public static void main(String[] args) {
whatTime wt = new whatTime(); // (1)
threadA ta = new threadA(wt); // (2)
ta.start(); // (3)
while (true) { }
}
}
public class threadA extends Thread {
private whatTime wt; // (4)
public threadA(whatTime wt) {
this.wt = wt; // (5)
}
public void run() {
while (true) {
try {
Thread.sleep(10000);
System.out.println("threadA: " + wt.getTime()); // (6)
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class whatTime {
public long getTime() {
return System.currentTimeMillis(); // (7)
}
}这段代码实际上是安全的，没有数据竞争问题。原因如下：
- 引用 wt 的初始化：在 mainClass 中 wt 引用被初始化一次（wt = new whatTime();），然后传递给 threadA。这个初始化操作 Happens-Before ta.start()，而 ta.start() 又 Happens-Before threadA 内部的任何操作。因此，threadA 总是能看到 wt 引用的正确值。由于 wt 引用本身在初始化后不再改变，所以对其的访问没有并发问题。
- whatTime 对象的状态：whatTime 类中只有一个方法 getTime()，它返回 System.currentTimeMillis()。这个方法不访问或修改 whatTime 对象的任何内部字段（即 whatTime 对象是无状态的）。System.currentTimeMillis() 是一个线程安全的操作，它从系统获取当前时间，不涉及共享的可变状态。
因此，尽管 threadA 在一个 while(true) 循环中，它对 wt.getTime() 的调用是完全安全的，并且不会与 mainClass 中的 while(true) 循环产生任何冲突。
总结与注意事项
- 区分引用与对象：理解引用变量存储的是对象的地址，而不是对象本身。多个线程可以持有同一个对象的引用，从而操作堆中同一个对象实例。
- 共享可变状态的风险：只有当多个线程同时访问并修改同一个共享的可变状态时，才需要担心数据竞争。如果对象是不可变的（immutable）或无状态的，或者每个线程只访问自己的私有状态，那么通常不需要额外的同步。
- Java内存模型：JMM定义了线程如何与主内存交互的规则，指令重排序和CPU缓存是导致并发问题的主要原因。
- Happens-Before原则：通过 synchronized、volatile、Thread.start() 等机制建立Happens-Before关系，确保内存可见性和操作顺序，是编写正确并发程序的关键。
- 使用并发工具：优先使用 java.util.concurrent 包中提供的并发工具类，它们已经封装了复杂的同步逻辑，并遵循JMM规则，能够大大简化并发编程的难度。
在Java中进行多线程编程时，务必深入理解对象、引用、内存模型和同步机制，才能避免潜在的并发陷阱，构建出高效且健壮的应用程序。
