本文深入探讨java多线程环境下对象与引用变量的交互机制。我们将澄清对象实例与引用变量的区别，解释为何一个线程能够访问由另一个线程创建的对象，即使该线程处于无限循环中。文章还将详细解析java内存模型（jmm）如何通过“happens-before”原则来确保多线程操作的可见性和有序性，并强调在共享可变状态时进行正确同步的重要性，以避免潜在的并发问题。
理解Java中的对象与引用
在Java中，理解对象和引用变量之间的区别是掌握多线程编程的基础。当我们在代码中执行 WhatTime wt = new WhatTime(); 这样的语句时，实际上发生了两个截然不同的操作：
- new WhatTime(): 这个操作在堆（Heap）内存中创建了一个 WhatTime 类的实例，即我们常说的“对象”。堆内存是所有线程共享的，对象的实际数据存储在这里。
- WhatTime wt: 这声明了一个引用变量 wt。这个引用变量本身存储在栈（Stack）内存中（如果是局部变量）或堆内存中（如果它是另一个对象的成员变量）。wt 并不存储 WhatTime 对象的实际数据，而是存储该对象在堆内存中的“地址”或“引用”。我们可以将其类比为“地址簿上的一页，上面写着房子的地址”，而房子本身才是对象。
当我们将 wt 这个引用变量传递给另一个线程时，例如 threadA ta = new threadA(wt);，Java采用的是值传递。这意味着 threadA 构造函数接收到的是 wt 引用变量的一个副本。现在，主线程和 threadA 都拥有指向堆中同一个 WhatTime 对象的地址。它们各自的引用变量是独立的，但它们都指向同一个共享的“房子”。因此，一个线程对这个共享对象进行的任何修改，都会被其他持有相同引用的线程观察到。
线程状态与对象访问
关于“如果一个线程处于 while(true) 循环中，就无法与其交互”的误解，需要澄清的是，一个线程是否处于循环中，并不直接决定其他线程能否访问它所创建或持有的对象。关键在于：
- 对象在堆上：无论创建对象的线程处于何种状态（运行、阻塞、等待），只要该对象存在于堆内存中，并且有其他线程持有指向它的引用，那么这些线程就可以访问该对象。
- 引用传递：通过将对象的引用传递给其他线程，这些线程就获得了访问该共享对象的“钥匙”。
因此，即使主线程在 while(true) 循环中，它已经将 whatTime 对象的引用传递给了 threadA。threadA 可以通过这个引用正常调用 wt.getTime() 方法，因为 getTime() 方法操作的是堆中的 whatTime 对象，而不是主线程的栈帧或其私有数据。
立即学习“Java免费学习笔记（深入）”；
Java内存模型（JMM）与并发挑战
尽管多个线程可以访问同一个共享对象，但这并不意味着所有并发访问都是安全的。现代CPU为了提高性能，会使用多级缓存。CPU核心不会直接读写主内存，而是操作其本地缓存。这导致了一个核心问题：一个线程对共享变量的修改可能只存在于其本地缓存中，而不会立即同步到主内存，其他线程可能因此读取到旧的（stale）数据。
为了解决这种内存可见性问题并确保并发程序的正确性，Java引入了Java内存模型（JMM）。JMM定义了程序中各种操作的可见性和有序性规则，其中最核心的概念是Happens-Before（先行发生）原则。
Happens-Before原则
如果操作A Happens-Before操作B，那么操作A的结果对操作B是可见的，并且操作A在时间上先于操作B发生。JMM通过一系列规则来建立Happens-Before关系，例如：
- 程序顺序规则：一个线程中的每个操作，Happens-Before于该线程中的任意后续操作。
- 管程锁定规则：对一个monitor的解锁Happens-Before于后续对这个monitor的加锁。
- volatile变量规则：对一个volatile变量的写操作Happens-Before于后续对这个volatile变量的读操作。
- 线程启动规则：Thread.start() 方法Happens-Before于该线程的每一个动作。
- 线程终止规则：线程中的所有操作Happens-Before于该线程的终止检测。
共享可变状态的风险
如果多个线程同时访问并修改同一个共享可变状态（即堆上可被修改的变量），并且没有建立Happens-Before关系来保证可见性和有序性，就会发生数据竞争（Data Race），导致不可预测的结果。
考虑以下示例：
class Example {
int x; // 共享可变状态
void crazy() {
x = 1; // 主线程写入
new Thread(() -> x = 5).start(); // 线程1写入
new Thread(() -> x = 10).start(); // 线程2写入
System.out.println(x); // 主线程读取
}
}在上述 Example 类中，x 是一个共享可变状态。主线程、线程1和线程2都在访问和修改 x。由于没有同步机制（如 synchronized 或 volatile）来建立Happens-Before关系，JMM不保证这些操作的可见性和有序性。因此，System.out.println(x) 的输出结果可能是1、5或10，甚至可能是其他意想不到的值（尽管不太常见）。Java虚拟机在不违反JMM规范的前提下，可以自由地进行指令重排和缓存优化。
确保并发安全的机制
为了避免数据竞争和确保并发程序的正确性，我们需要使用JMM提供的同步机制来建立Happens-Before关系：
- synchronized 关键字：用于实现互斥锁，确保同一时间只有一个线程可以执行被保护的代码块。
- volatile 关键字：确保变量的可见性，即对volatile变量的写操作会立即刷新到主内存，读操作会从主内存中重新加载。
- java.util.concurrent 包：提供了丰富的并发工具类，如 AtomicInteger、ConcurrentHashMap、CountDownLatch 等，它们内部已经处理了同步和内存可见性问题。
分析原始代码示例
回到最初的问题代码：
public class mainClass {
public static void main(String[] args) {
whatTime wt = new whatTime(); // 1. 创建对象并获取引用
threadA ta = new threadA(wt); // 2. 将引用传递给新线程
ta.start(); // 3. 启动线程A
while (true) { // 4. 主线程进入无限循环
// ...
}
}
}
public class threadA extends Thread {
private whatTime wt;
public threadA(whatTime wt) {
this.wt = wt; // 接收引用副本
}
public void run() {
while (true) {
try {
Thread.sleep(10000);
System.out.println("threadA: " + wt.getTime()); // 5. 访问共享对象
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class whatTime {
public long getTime() {
return System.currentTimeMillis(); // 6. 获取系统时间
}
}在这个特定的代码示例中，不存在并发问题。原因如下：
- wt 引用是只读的：whatTime wt = new whatTime(); 语句在主线程中执行，随后 wt 引用被传递给 threadA。在 mainClass 或 threadA 中，wt 这个引用本身都没有被重新赋值或修改，因此它是一个effectively final的引用。
- whatTime 对象是不可变或只读的：whatTime 类中只有一个 getTime() 方法，它返回 System.currentTimeMillis()。System.currentTimeMillis() 是一个静态方法，它不访问 whatTime 对象的任何成员字段，也不会修改 whatTime 对象的内部状态。换句话说，whatTime 对象本身并没有任何可变的共享状态。
由于 wt 引用是稳定的，并且 whatTime 对象本身没有可变的共享状态，threadA 调用 wt.getTime() 不会导致任何数据竞争。JMM的线程启动规则保证了 wt 引用在 ta.start() 之前被完全初始化，并且对 threadA 可见。因此，这段代码是完全安全的，并且能够按预期工作。
总结
理解Java中对象与引用的分离是多线程编程的关键。对象存储在所有线程共享的堆内存中，而引用变量则指向这些对象。通过传递引用，多个线程可以访问同一个对象。然而，这种共享访问必须通过Java内存模型（JMM）定义的同步机制（如synchronized、volatile或java.util.concurrent工具）进行妥善管理，以确保对共享可变状态的可见性和有序性，从而避免数据竞争和不可预测的行为。在没有共享可变状态的情况下，多个线程访问同一个对象通常是安全的。
