线程间通信是指多个线程在执行过程中，为了完成某项任务而交换信息或协调工作。Java 提供了多种线程间通信的方式，以下是几种常见的方法：

1.使用共享变量

共享变量是线程间通信最基本的方式，通过访问共享的内存变量，线程可以相互传递数据。

实现方式：

• 线程通过共享对象的字段进行数据交换。
• 使用volatile关键字确保线程能感知变量的最新值。
• 需要使用sychronized或Lock来保护共享数据的访问，避免竞态条件。

示例代码：

java

class SharedData {
    private int data = 0;
    private boolean available = false;

    public synchronized void produce(int value) {
        while (available) { // 等待数据被消费
            try {
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        data = value;
        available = true;
        notifyAll(); // 通知消费者
    }

    public synchronized int consume() {
        while (!available) { // 等待数据生产
            try {
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        available = false;
        notifyAll(); // 通知生产者
        return data;
    }
} 

2.wait和notify/notifyAll

Java 中的Object类提供了wait、notify和notifyAll方法，用于线程间的通信。
这些方法需要与synchronized关键字配合使用，并在同一监视器锁对象上调用。

注意点：

• wait()：当前线程进入等待状态，释放锁并挂起，直到收到通知。
• notify()：唤醒一个等待线程。
• notifyAll()：唤醒所有等待线程。

典型场景：生产者-消费者模式

3.通过线程安全的队列

Java 提供了一些线程安全的队列（例如BlockingQueue），可以简化线程间的通信过程。这种方式无需手动控制锁，大大降低了复杂性。

常用的阻塞队列：

• ArrayBlockingQueue：基于数组的有界队列。
• LinkedBlockingQueue：基于链表的队列，支持可选界限。
• PriorityBlockingQueue：支持优先级排序的无界队列。

示例代码：

java

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class QueueCommunication {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);

        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    queue.put(i); // 将数据放入队列
                    System.out.println("Produced: " + i);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread consumer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    int value = queue.take(); // 从队列中获取数据
                    System.out.println("Consumed: " + value);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        producer.start();
        consumer.start();
    }
} 

4.使用信号量（Semaphore）

Semaphore可以用作线程间的一种信号机制，允许指定数量的线程同时访问共享资源。

典型用法：

• 生产者与消费者间的同步。
• 限制并发访问资源的线程数量。

示例代码：

java

import java.util.concurrent.Semaphore;

class SemaphoreExample {
    private final Semaphore semaphore = new Semaphore(1);
    private int sharedData = 0;

    public void produce() {
        try {
            semaphore.acquire();
            sharedData++;
            System.out.println("Produced: " + sharedData);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            semaphore.release();
        }
    }

    public void consume() {
        try {
            semaphore.acquire();
            System.out.println("Consumed: " + sharedData);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            semaphore.release();
        }
    }
} 

5.Future和CompletableFuture

在并发任务的返回值处理中，Future和CompletableFuture是两个重要的工具类。它们可以实现线程间数据的传递，同时支持异步操作。

特点：

• Future：提供简单的获取异步结果的方法。
• CompletableFuture：提供丰富的链式编程接口，适合复杂的异步操作。

示例代码（CompletableFuture）：

java

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture.supplyAsync(() -> {
            System.out.println("Producing data...");
            return "Data";
        }).thenAccept(result -> {
            System.out.println("Consumed: " + result);
        });
    }
} 

6.基于消息的通信

通过消息队列（如Kafka、RabbitMQ）或 Java 提供的消息传递机制，可以实现线程间通信。这种方式通常用于更复杂的分布式系统中，但在单机线程通信中也有应用。

核心优点： 解耦线程，异步处理。

总结

Java 中线程间通信的方式各有特点，适用于不同场景：

选择合适的通信方式，能够显著提升程序的性能和可维护性。