Java 线程间如何实现协作

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

1. 共享变量：通过在多个线程之间共享一个或多个变量，可以让线程相互影响彼此的执行。为了确保数据的一致性，可以使用 synchronized 关键字或者 java.util.concurrent 包中的类（如 ReentrantLock、AtomicInteger 等）来同步访问共享资源。

2. 等待/通知机制：Java 提供了 wait() 和 notify() 方法，用于线程间的协作。当一个线程调用某个对象的 wait() 方法时，它会释放该对象的锁并进入等待状态。另一个线程调用相同对象的 notify() 方法时，会将等待状态的线程唤醒。这种机制通常与 synchronized 关键字一起使用。

示例：

class SharedResource {
    synchronized void waitForSignal() throws InterruptedException {
        wait(); // 当前线程进入等待状态
    }

    synchronized void sendSignal() {
        notify(); // 唤醒等待状态的线程
    }
}

3. 阻塞队列（BlockingQueue）：Java 提供了阻塞队列接口（BlockingQueue）及其实现类（如 ArrayBlockingQueue、LinkedBlockingQueue 等），用于线程间安全地传递数据。阻塞队列支持在队列为空时获取元素的线程等待，以及在队列已满时添加元素的线程等待。

示例：

BlockingQueue<String> queue = new LinkedBlockingQueue<>();

new Thread(() -> {
    try {
        String item = queue.take(); // 获取队列中的元素，若队列为空则等待
        System.out.println("Received: " + item);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}).start();

new Thread(() -> {
    try {
        queue.put("Hello"); // 向队列中添加元素，若队列已满则等待
        System.out.println("Sent: Hello");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}).start();

4. 信号量（Semaphore）：Java 提供了信号量类（Semaphore），用于控制对共享资源的访问。信号量的计数器表示可用资源的数量。当一个线程尝试获取资源时，如果计数器大于零，则线程可以继续执行并减少计数器；否则，线程将被阻塞，直到其他线程释放资源。

示例：

import java.util.concurrent.Semaphore;

class SharedResource {
    private final Semaphore semaphore = new Semaphore(3); // 最多允许 3 个线程同时访问

    void doSomething() throws InterruptedException {
        semaphore.acquire(); // 获取信号量，若信号量为零则等待
        try {
            // 执行操作
        } finally {
            semaphore.release(); // 释放信号量
        }
    }
}

5. CountDownLatch：Java 提供了 CountDownLatch 类，用于让一个或多个线程等待其他线程完成操作。CountDownLatch 的计数器初始化为一个正整数，当所有等待线程调用 countDown() 方法时，计数器减一。当计数器减至零时，所有等待线程被唤醒。

示例：

import java.util.concurrent.CountDownLatch;

class WorkerThread extends Thread {
    private final CountDownLatch latch;

    public WorkerThread(CountDownLatch latch) {
        this.latch = latch;
    }

    @Override
    public void run() {
        try {
            // 执行操作
        } finally {
            latch.countDown(); // 完成操作后减少计数器
        }
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        int numberOfThreads = 5;
        CountDownLatch latch = new CountDownLatch(numberOfThreads);

        for (int i = 0; i < numberOfThreads; i++) {
            new WorkerThread(latch).start();
        }

        latch.await(); // 等待所有线程完成操作
        System.out.println("All threads have finished.");
    }
}

这些方法可以根据具体需求组合使用，以实现线程间的协作。