Java多线程：线程间如何通信

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

1. wait() 和 notify() 方法： 这两个方法用于线程间的协作，它们是 Object 类的一部分。当一个线程调用另一个线程的 wait() 方法时，当前线程会释放锁并进入等待状态。当另一个线程调用同一个对象的 notify() 方法时，等待状态的线程会被唤醒并重新获取锁。这种方式需要使用 synchronized 关键字来确保线程安全。

示例：

public class SharedResource {
    private boolean isReady = false;

    public synchronized void waitForSignal() throws InterruptedException {
        while (!isReady) {
            wait();
        }
        System.out.println("线程 " + Thread.currentThread().getName() + " 收到信号");
    }

    public synchronized void sendSignal() {
        isReady = true;
        notify();
    }
}

2. Condition 接口： Condition 接口提供了更灵活的线程间通信方式，它是 java.util.concurrent.locks.Lock 接口的一部分。通过 Lock 对象创建 Condition 对象，然后使用 await() 和 signal() 方法进行线程间的等待和唤醒。

示例：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SharedResource {
    private boolean isReady = false;
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();

    public void waitForSignal() throws InterruptedException {
        lock.lock();
        try {
            while (!isReady) {
                condition.await();
            }
            System.out.println("线程 " + Thread.currentThread().getName() + " 收到信号");
        } finally {
            lock.unlock();
        }
    }

    public void sendSignal() {
        lock.lock();
        try {
            isReady = true;
            condition.signal();
        } finally {
            lock.unlock();
        }
    }
}

3. CountDownLatch： CountDownLatch 是一个同步辅助类，它允许一个或多个线程等待其他线程完成操作。通过构造函数指定计数器，每次调用 countDown() 方法时，计数器减1。线程调用 await() 方法等待计数器变为0。

示例：

import java.util.concurrent.CountDownLatch;

public class SharedResource {
    private final CountDownLatch latch;

    public SharedResource(int count) {
        latch = new CountDownLatch(count);
    }

    public void waitForSignal() throws InterruptedException {
        latch.await();
        System.out.println("线程 " + Thread.currentThread().getName() + " 收到信号");
    }

    public void sendSignal() {
        latch.countDown();
    }
}

4. CyclicBarrier： CyclicBarrier 是一个同步辅助类，它允许一组线程互相等待，直到所有线程都准备好继续执行。通过构造函数指定参与等待的线程数量，当所有线程都调用 await() 方法时，它们会一起继续执行。

示例：

import java.util.concurrent.CyclicBarrier;

public class SharedResource {
    private final CyclicBarrier barrier;

    public SharedResource(int count) {
        barrier = new CyclicBarrier(count);
    }

    public void waitForSignal() throws InterruptedException {
        try {
            barrier.await();
            System.out.println("线程 " + Thread.currentThread().getName() + " 收到信号");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void sendSignal() {
        barrier.await();
    }
}

这些方法都可以实现线程间的通信，具体选择哪种方式取决于你的需求和应用场景。