当前位置：首页 > 文章列表 > 文章 > java教程 > Java并发线程交互详解

Java并发线程交互详解

2025-12-17 08:30:42 0浏览收藏

推广推荐

支持 PC / 移动端，安全直达

golang学习网今天将给大家带来《Java并发对象与线程交互全解析》，感兴趣的朋友请继续看下去吧！以下内容将会涉及到等等知识点，如果你是正在学习文章或者已经是大佬级别了，都非常欢迎也希望大家都能给我建议评论哈~希望能帮助到大家！

Java并发编程中对象与线程的交互机制详解

本文深入探讨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 对象则存在于堆中。栈空间是线程私有的，当方法返回时，栈帧会被立即回收，其他线程无法直接访问。然而，堆内存是所有线程共享的。

线程如何共享对象

当我们将一个对象的引用传递给另一个线程时，例如：

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中进行多线程编程时，务必深入理解对象、引用、内存模型和同步机制，才能避免潜在的并发陷阱，构建出高效且健壮的应用程序。

今天带大家了解了的相关知识，希望对你有所帮助；关于文章的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~