当前位置：首页 > news >正文

Java线程通信：多线程程序中的高效协作！

news 2025/11/9 13:25:17

开篇语

哈喽，各位小伙伴们，你们好呀，我是喵手。运营社区：C站/掘金/腾讯云/阿里云/华为云/51CTO；欢迎大家常来逛逛

今天我要给大家分享一些自己日常学习到的一些知识点，并以文字的形式跟大家一起交流，互相学习，一个人虽可以走的更快，但一群人可以走的更远。

我是一名后端开发爱好者，工作日常接触到最多的就是Java语言啦，所以我都尽量抽业余时间把自己所学到所会的，通过文章的形式进行输出，希望以这种方式帮助到更多的初学者或者想入门的小伙伴们，同时也能对自己的技术进行沉淀，加以复盘，查缺补漏。

小伙伴们在批阅的过程中，如果觉得文章不错，欢迎点赞、收藏、关注哦。三连即是对作者我写作道路上最好的鼓励与支持！

前言

在多线程编程中，线程之间的协作和通信是一个关键问题。通常，在一些复杂的应用场景中，我们需要多个线程相互协作、传递数据或共享资源，如何在这些线程之间安全、有效地进行通信是我们必须掌握的一项技能。Java为我们提供了多种线程通信机制，例如wait()、notify()、notifyAll()方法，生产者消费者模式，线程间数据传递，ThreadLocal的使用，以及线程池的概念。

在本篇文章中，我们将详细介绍这些概念和技术，帮助你理解如何在多线程环境下进行高效的线程通信。

1. wait()、notify()、notifyAll()方法：线程间的基本通信机制

Java中的线程通信机制主要依赖于Object类中的三个方法：wait()、notify()和notifyAll()。这些方法允许线程之间通过共享的对象进行协调，控制线程的执行顺序。

wait()方法：

wait()方法让当前线程进入等待状态，直到其他线程调用相同对象的notify()或notifyAll()方法唤醒它。线程在调用wait()时必须持有该对象的锁（即在同步代码块或同步方法中调用）。

常见用途：等待某个条件满足，比如生产者线程等待消费者线程消费产品。

示例：

synchronized (sharedObject) {while (conditionNotMet) {sharedObject.wait(); // 当前线程等待}
}

notify()方法：

notify()方法唤醒一个正在等待该对象锁的线程。若有多个线程在等待该对象的锁，notify()将唤醒其中一个线程，而notifyAll()则会唤醒所有等待线程。

常见用途：当某个线程完成了某项工作后，通知其他线程继续执行。

示例：

synchronized (sharedObject) {sharedObject.notify(); // 唤醒一个等待线程
}

notifyAll()方法：

notifyAll()方法唤醒所有等待该对象锁的线程。与notify()不同，notifyAll()会唤醒所有等待线程，它适用于当多个线程在等待同一条件时。

常见用途：当多个线程依赖相同的条件时，唤醒所有等待的线程进行工作。

示例：

synchronized (sharedObject) {sharedObject.notifyAll(); // 唤醒所有等待线程
}

总结：

wait()：使线程进入等待状态。
notify()：唤醒一个等待的线程。
notifyAll()：唤醒所有等待的线程。

2. 生产者消费者模式：线程协作的经典例子

生产者消费者模式是多线程编程中最经典的模式之一。在该模式下，生产者线程生产数据，消费者线程消费数据，生产者和消费者共享同一个缓冲区（通常是一个队列）。生产者消费者模式的关键是保证生产者和消费者之间的协调，使得生产者不会在缓冲区满时继续生产，消费者不会在缓冲区空时继续消费。

核心问题：

生产者如何知道缓冲区是否已满？
消费者如何知道缓冲区是否为空？
如何实现生产者与消费者之间的协调？

解决方案：

通过使用wait()和notify()，生产者和消费者可以在缓冲区已满或为空时进行相应的等待和通知。生产者在缓冲区满时等待，消费者在缓冲区空时等待，直到有空余空间或新数据被添加。

示例：生产者消费者模式

class SharedBuffer {private List<Integer> buffer = new ArrayList<>();private final int MAX_SIZE = 5;// 生产者生产数据public synchronized void produce() throws InterruptedException {while (buffer.size() == MAX_SIZE) {wait(); // 如果缓冲区满，生产者等待}buffer.add(1); // 添加一个产品System.out.println("生产者生产了一个产品，当前缓冲区大小：" + buffer.size());notifyAll(); // 通知消费者}// 消费者消费数据public synchronized void consume() throws InterruptedException {while (buffer.isEmpty()) {wait(); // 如果缓冲区为空，消费者等待}buffer.remove(0); // 消费一个产品System.out.println("消费者消费了一个产品，当前缓冲区大小：" + buffer.size());notifyAll(); // 通知生产者}
}class Producer extends Thread {private SharedBuffer buffer;public Producer(SharedBuffer buffer) {this.buffer = buffer;}@Overridepublic void run() {try {while (true) {buffer.produce();Thread.sleep(1000); // 模拟生产间隔}} catch (InterruptedException e) {e.printStackTrace();}}
}class Consumer extends Thread {private SharedBuffer buffer;public Consumer(SharedBuffer buffer) {this.buffer = buffer;}@Overridepublic void run() {try {while (true) {buffer.consume();Thread.sleep(1500); // 模拟消费间隔}} catch (InterruptedException e) {e.printStackTrace();}}
}public class TestProducerConsumer {public static void main(String[] args) {SharedBuffer buffer = new SharedBuffer();Producer producer = new Producer(buffer);Consumer consumer = new Consumer(buffer);producer.start();consumer.start();}
}

在这个例子中，生产者和消费者共享SharedBuffer对象，通过wait()和notifyAll()实现了线程间的协调，确保生产者在缓冲区满时等待，消费者在缓冲区空时等待。

3. 线程间数据传递：共享数据和通信

在多线程编程中，线程间的数据传递是常见的需求，通常有两种方式：

共享数据： 多个线程共享同一数据结构（如共享队列、缓冲区等）。使用wait()、notify()、synchronized等机制确保数据的一致性和线程安全。
线程间通信： 可以通过管道、消息队列、回调等方式来进行线程间的通信。

示例：共享数据传递

class SharedData {private int data;public synchronized void setData(int value) {this.data = value;notify(); // 通知其他线程数据已准备好}public synchronized int getData() throws InterruptedException {while (data == 0) {wait(); // 等待数据被设置}return data;}
}class Producer extends Thread {private SharedData sharedData;public Producer(SharedData sharedData) {this.sharedData = sharedData;}@Overridepublic void run() {try {while (true) {sharedData.setData(1); // 设置数据System.out.println("生产者设置了数据");Thread.sleep(1000);}} catch (InterruptedException e) {e.printStackTrace();}}
}class Consumer extends Thread {private SharedData sharedData;public Consumer(SharedData sharedData) {this.sharedData = sharedData;}@Overridepublic void run() {try {while (true) {int data = sharedData.getData(); // 获取数据System.out.println("消费者获取了数据：" + data);Thread.sleep(1500);}} catch (InterruptedException e) {e.printStackTrace();}}
}public class TestDataTransfer {public static void main(String[] args) {SharedData sharedData = new SharedData();Producer producer = new Producer(sharedData);Consumer consumer = new Consumer(sharedData);producer.start();consumer.start();}
}

在这个示例中，生产者线程设置数据，消费者线程等待并获取数据，通过wait()和notify()进行线程间的数据传递。

4. ThreadLocal的使用：线程局部变量

ThreadLocal是一个可以为每个线程提供独立变量副本的类。每个线程访问ThreadLocal时，都能得到不同的变量副本，这样就避免了多线程访问同一共享变量时的同步问题。

示例：使用ThreadLocal

public class TestThreadLocal {private static ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 1);public static void main(String[] args) {Runnable task = () -> {int value = threadLocal.get();System.out.println(Thread.currentThread().getName() + " Value: " + value);threadLocal.set(value + 1);  // 每个线程的值独立};Thread t1 = new Thread(task);Thread t2 = new Thread(task);t1.start();t2.start();}
}

在这个示例中，ThreadLocal为每个线程提供了独立的变量副本，避免了多个线程之间的竞争和同步问题。

5. 线程池的概念：高效管理线程

线程池是用来管理和复用线程的工具，避免了频繁地创建和销毁线程所带来的性能开销。Java中的Executor框架提供了多种线程池的实现。

线程池的优势：

减少资源消耗：通过复用已有线程，避免了线程的频繁创建和销毁。
提高性能：控制最大并发线程数，避免过多线程导致的资源争用。
线程管理：线程池能够有效地管理线程的生命周期，并提供任务调度。

创建线程池：

import java.util.concurrent.*;public class TestThreadPool {public static void main(String[] args) {ExecutorService executorService = Executors.newFixedThreadPool(2);Runnable task = () -> {System.out.println(Thread.currentThread().getName() + " is executing the task");};executorService.submit(task);executorService.submit(task);executorService.shutdown();}
}