在Java中，线程间通信可以通过以下方式实现：

1.共享变量

线程可以通过共享的变量进行通信。多个线程可以读写同一个变量来交换信息。在这种情况下，需要确保线程对共享变量的访问是同步的，以避免数据竞争和不一致的结果。

以下是一个使用共享变量进行线程通信的示例代码：

class Message {private String content;private boolean hasNewMessage = false;public synchronized void putMessage(String content) {while (hasNewMessage) {try {wait(); // 等待直到消息被消费} catch (InterruptedException e) {Thread.currentThread().interrupt();}}this.content = content;hasNewMessage = true;notifyAll(); // 唤醒等待的线程}public synchronized String getMessage() {while (!hasNewMessage) {try {wait(); // 等待直到有新消息} catch (InterruptedException e) {Thread.currentThread().interrupt();}}hasNewMessage = false;notifyAll(); // 唤醒等待的线程return content;}
}class Producer implements Runnable {private Message message;public Producer(Message message) {this.message = message;}public void run() {String[] messages = { "Hello", "World", "Goodbye" };for (String msg : messages) {message.putMessage(msg);System.out.println("Producer: " + msg);try {Thread.sleep(1000); // 模拟耗时操作} catch (InterruptedException e) {Thread.currentThread().interrupt();}}message.putMessage("Done");}
}class Consumer implements Runnable {private Message message;public Consumer(Message message) {this.message = message;}public void run() {String msg = "";while (!msg.equals("Done")) {msg = message.getMessage();System.out.println("Consumer: " + msg);}}
}public class Main {public static void main(String[] args) {Message message = new Message();Thread producerThread = new Thread(new Producer(message));Thread consumerThread = new Thread(new Consumer(message));producerThread.start();consumerThread.start();}
}

在这个示例中，有一个Message类，它表示一个消息对象。Message类中的putMessage方法用于生产消息，并将消息存储在content变量中。getMessage方法用于消费消息，并返回存储的消息内容。这两个方法都使用synchronized关键字来实现同步，以确保线程安全。

有一个Producer类，它实现了Runnable接口，用于在一个线程中生产消息。Consumer类也实现了Runnable接口，用于在另一个线程中消费消息。

在Main类的main方法中，创建了一个Message对象，并创建了一个生产者线程和一个消费者线程。通过调用start方法启动这两个线程，它们将并发地生产和消费消息。

在控制台输出中，我们将看到生产者线程和消费者线程交替输出消息，它们通过共享的Message对象进行通信。

2.等待/通知机制

Java提供了wait、notify和notifyAll方法，用于线程间的等待和通知。线程可以调用wait方法暂停自己的执行，直到另一个线程调用相同对象上的notify或notifyAll方法来唤醒它们。

以下是一个使用等待/通知机制进行线程通信的示例代码：

class Message {private String content;private boolean hasNewMessage = false;public synchronized void putMessage(String content) {while (hasNewMessage) {try {wait(); // 等待直到消息被消费} catch (InterruptedException e) {Thread.currentThread().interrupt();}}this.content = content;hasNewMessage = true;notifyAll(); // 唤醒等待的线程}public synchronized String getMessage() {while (!hasNewMessage) {try {wait(); // 等待直到有新消息} catch (InterruptedException e) {Thread.currentThread().interrupt();}}hasNewMessage = false;notifyAll(); // 唤醒等待的线程return content;}
}class Producer implements Runnable {private Message message;public Producer(Message message) {this.message = message;}public void run() {String[] messages = { "Hello", "World", "Goodbye" };for (String msg : messages) {message.putMessage(msg);System.out.println("Producer: " + msg);try {Thread.sleep(1000); // 模拟耗时操作} catch (InterruptedException e) {Thread.currentThread().interrupt();}}message.putMessage("Done");}
}class Consumer implements Runnable {private Message message;public Consumer(Message message) {this.message = message;}public void run() {String msg = "";while (!msg.equals("Done")) {msg = message.getMessage();System.out.println("Consumer: " + msg);}}
}public class Main {public static void main(String[] args) {Message message = new Message();Thread producerThread = new Thread(new Producer(message));Thread consumerThread = new Thread(new Consumer(message));producerThread.start();consumerThread.start();}
}

这个示例中的代码与之前的示例相同。不同之处在于，putMessage和getMessage方法使用了wait和notifyAll方法来进行线程间的等待和通知。当putMessage方法调用wait时，它会释放对象的锁并等待被唤醒。当getMessage方法调用notifyAll时，它会唤醒等待的线程并重新获得对象的锁。

通过这种方式，生产者线程在没有新消息时等待，直到消费者线程消费了消息并调用notifyAll方法。同样，消费者线程在没有新消息时等待，直到生产者线程产生新消息并调用notifyAll方法。

无论是共享变量还是等待/通知机制，Java提供了多种方法来实现线程间的通信。选择适当的方法取决于特定的应用场景和需求。