Java多线程中对象与引用的交互及内存模型深度解析

本文深入探讨java多线程环境下对象与引用变量的交互机制。我们将澄清对象实例与引用变量的区别，解释为何一个线程能够访问由另一个线程创建的对象，即使该线程处于无限循环中。文章还将详细解析java内存模型（jmm）如何通过“happens-before”原则来确保多线程操作的可见性和有序性，并强调在共享可变状态时进行正确同步的重要性，以避免潜在的并发问题。

理解Java中的对象与引用

在Java中，理解对象和引用变量之间的区别是掌握多线程编程的基础。当我们在代码中执行 WhatTime wt = new WhatTime(); 这样的语句时，实际上发生了两个截然不同的操作：

1. new WhatTime(): 这个操作在堆（Heap）内存中创建了一个 WhatTime 类的实例，即我们常说的“对象”。堆内存是所有线程共享的，对象的实际数据存储在这里。
2. 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），导致不可预测的结果。

腾讯交互翻译

腾讯AI Lab发布的一款AI辅助翻译产品

183

查看详情

考虑以下示例：

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. 获取系统时间
   }
}

在这个特定的代码示例中，不存在并发问题。原因如下：

1. wt 引用是只读的：whatTime wt = new whatTime(); 语句在主线程中执行，随后 wt 引用被传递给 threadA。在 mainClass 或 threadA 中，wt 这个引用本身都没有被重新赋值或修改，因此它是一个effectively final的引用。
2. 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工具）进行妥善管理，以确保对共享可变状态的可见性和有序性，从而避免数据竞争和不可预测的行为。在没有共享可变状态的情况下，多个线程访问同一个对象通常是安全的。

以上就是Java多线程中对象与引用的交互及内存模型深度解析的详细内容，更多请关注php中文网其它相关文章！