深入理解Java对象与线程交互：堆、栈与内存模型-java教程-PHP中文网

深入理解java对象与线程交互：堆、栈与内存模型

本文旨在阐明Java中线程如何与对象交互的机制，特别是区分栈上的局部引用变量与堆上的实际对象。我们将探讨即使线程处于无限循环中，为何仍能访问共享对象的方法，并深入解析Java内存模型（JMM）在多线程环境下确保数据一致性的重要性，包括“Happens-Before”原则及其应用，最终分析示例代码以消除常见误解。

Java中对象、引用与线程：核心概念

在Java中，理解对象、引用以及它们在内存中的存储方式是理解多线程交互的基础。当我们声明一个对象时，例如 whatTime wt = new whatTime();，实际上发生了两件截然不同的事情：

声明引用变量 (wt)： wt 是一个引用变量，它存储在当前线程的栈空间中。它本身并不是 whatTime 类的实例，而是一个指向实际对象的“地址”或“指针”。这个引用变量是线程私有的，其他线程无法直接访问。可以将其类比为一本地址簿中的一页，上面写着一个房子的地址。
创建对象实例 (new whatTime())： new whatTime() 操作会在Java堆（Heap）上创建一个 whatTime 类的实际实例。堆是所有线程共享的内存区域。这个实例就是我们所说的“房子”。创建后，其在堆上的地址会被赋值给栈上的引用变量 wt。

当我们将一个引用变量（如 wt）传递给另一个线程时，例如 threadA ta = new threadA(wt);，我们传递的是这个引用变量的副本。这意味着 mainClass 中的 wt 和 threadA 中的 wt 虽然是两个独立的引用变量，但它们都指向堆上的同一个 whatTime 对象实例。就像两个人各自拥有一本地址簿，上面都写着同一个房子的地址。因此，任何一个线程通过其持有的引用去操作这个共享对象（比如调用其方法），都会影响到堆上那个唯一的对象实例，并且这些影响对其他持有相同引用的线程是可见的。

线程阻塞与对象交互的误区

一个常见的误解是，如果一个线程处于 while(true) 循环中，就无法与其他线程或其声明的对象进行交互。实际上，线程是否处于循环中，与它是否能够访问堆上的对象是两个独立的概念。只要线程持有对象的引用，并且该对象位于共享的堆内存中，那么无论该线程是在循环、休眠还是执行其他任务，它都可以通过该引用来调用对象的方法或访问其字段。

立即学习“Java免费学习笔记（深入）”；

线程在 while(true) 循环中，意味着它正在“运行”或“忙碌”。这里的“无法交互”通常是指无法直接访问该线程私有栈上的局部变量，因为这些变量是线程隔离的。然而，堆上的对象是共享的，只要线程能够获取到对象的引用，就可以对其进行操作。

Java内存模型（JMM）与并发一致性

在多线程环境中，仅仅能够访问共享对象是不够的，还需要确保数据的一致性。现代CPU为了提高性能，通常会使用多级缓存。这意味着线程对共享变量的修改可能首先发生在CPU的本地缓存中，而不是直接写入主内存。这可能导致其他线程无法立即看到最新的修改，从而引发数据不一致问题。

Java内存模型（JMM）正是为了解决这些并发问题而设计的。JMM定义了在多线程环境下，一个线程对共享变量的写入何时对另一个线程可见的规则，即“Happens-Before”原则。

Quinvio AI

AI辅助下快速创建视频，虚拟代言人

查看详情

Happens-Before 原则

“Happens-Before”原则是JMM的核心，它定义了操作之间的偏序关系。如果一个操作A Happens-Before 操作B，那么操作A的结果对操作B是可见的，并且操作A在操作B之前执行。常见的Happens-Before规则包括：

程序顺序规则： 同一个线程中，前面的操作Happens-Before后面的操作。
监视器锁规则： 对一个监视器锁的解锁Happens-Before后续对这个监视器锁的加锁。
volatile变量规则： 对一个volatile变量的写操作Happens-Before后续对这个volatile变量的读操作。
Thread.start()规则： Thread.start() 方法的调用Happens-Before此线程中的任何操作。
Thread.join()规则： 线程A调用线程B的 join() 方法并成功返回，那么线程B中的所有操作Happens-Before线程A从 join() 方法返回后的任何操作。
传递性： 如果A Happens-Before B，且B Happens-Before C，那么A Happens-Before C。

数据竞争与可见性问题示例

当多个线程在没有适当同步的情况下访问和修改同一个共享变量时，就会发生数据竞争，导致不可预测的结果。考虑以下示例：

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);
  }
}

登录后复制

在上述 Example 类中，x 是一个共享变量。主线程初始化 x 为1，然后启动两个新线程，分别将 x 修改为5和10。由于没有使用任何同步机制（如 synchronized 或 volatile）来建立Happens-Before关系，System.out.println(x) 打印的值可能是1、5或10，甚至可能是其他意想不到的值（尽管在大多数JVM实现中不太可能）。JVM规范允许这种行为，因为它无法保证这些写入操作的顺序和可见性。这种代码是不可靠的，因为它依赖于JVM、操作系统、CPU架构甚至运行时的随机因素。

示例代码分析

现在，让我们回到最初的示例代码，并分析它为何没有并发问题：

mainClass.java

/**
 * main
 */
public class mainClass {
   public static void main(String[] args) {
      whatTime wt = new whatTime(); // (1) 创建whatTime对象并赋值给引用wt
      threadA ta = new threadA(wt); // (2) 将wt引用传递给threadA的构造器
      ta.start(); // (3) 启动threadA线程

      while (true) {
         // 主线程在此处无限循环
      }
   }
}

登录后复制

threadA.java

/**
 * threadA
 */
public class threadA extends Thread {
   private whatTime wt; // (4) threadA内部持有whatTime对象的引用

   public threadA(whatTime wt) {
      System.out.println("threadA() constructor");
      this.wt = wt; // (5) 接收并保存whatTime对象的引用
   }

   public void run() {
      while (true) {
         //每10秒执行一次
         try {
            Thread.sleep(10000);
            System.out.println("threadA: " + wt.getTime()); // (6) 调用共享对象的方法
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      }
   }
}

登录后复制

whatTime.java

public class whatTime {
   public whatTime() {
      System.out.println("whatTime() constructor");
   }

   public long getTime() {
      return System.currentTimeMillis(); // (7) 获取当前时间戳
   }
}

登录后复制

分析：

引用传递与Happens-Before： 在 mainClass 中，whatTime wt = new whatTime(); 创建了一个 whatTime 对象。然后，这个 wt 引用被传递给 threadA 的构造器，并在 threadA 启动 (ta.start()) 之前完成。根据JMM的 Thread.start() 规则，主线程中 ta.start() 之前的操作（包括 wt 的初始化和传递）Happens-Before threadA 线程中的任何操作。这意味着当 threadA 线程开始执行时，它对 wt 引用指向的 whatTime 对象是完全可见的，并且该引用本身在被传递后没有再被修改。
whatTime 对象的特性： whatTime 类非常简单，它只有一个 getTime() 方法，该方法仅仅返回 System.currentTimeMillis()。System.currentTimeMillis() 是一个静态方法，它不依赖于 whatTime 对象的任何内部状态（字段）。换句话说，whatTime 对象本身是无状态的，或者说它的状态在被创建后没有被任何线程修改。
无共享可变状态： 由于 whatTime 对象没有可变的实例字段，并且其 getTime() 方法不涉及任何共享可变状态的读写，因此多个线程同时调用 wt.getTime() 不会引发数据竞争。每个线程都会独立地调用 System.currentTimeMillis() 并获取当前时间戳。

结论： 该示例代码是完全正确的，并且在多线程环境下不会出现数据一致性问题。主线程的 while(true) 循环虽然使其自身忙碌，但并不妨碍 threadA 线程通过其持有的引用访问堆上的 whatTime 对象。关键在于 whatTime 对象本身是线程安全的，因为它不包含任何可变的共享状态。

总结与注意事项

区分引用与对象： 栈上存储的是局部引用变量，堆上存储的是实际对象实例。多个线程可以持有指向同一个堆上对象的引用。
线程交互： 线程即使在无限循环中，只要持有对象的引用，就可以与堆上的共享对象进行交互。
Java内存模型（JMM）： 理解JMM及其“Happens-Before”原则对于编写正确的并发程序至关重要。它确保了共享变量在多线程环境下的可见性和一致性。
数据竞争： 当多个线程在没有适当同步的情况下访问和修改共享的可变状态时，就会发生数据竞争，导致不可预测的结果。
线程安全设计： 在设计多线程程序时，应特别注意共享可变状态的访问。如果对象是无状态的或其所有状态都是不可变的，那么它通常是线程安全的。如果对象包含可变状态，则必须使用 synchronized、volatile 或 java.util.concurrent 包中的工具来确保线程安全。