Java Thread.join有哪些常见的并发编程模式

在Java中，Thread.join()方法用于等待一个线程执行完毕后再继续执行当前线程。以下是一些常见的并发编程模式，这些模式中可能会使用到Thread.join()来实现线程间的协作：

1. 串行执行：在这种模式下，所有线程按照顺序一个接一个地执行。可以使用Thread.join()来确保某个线程在另一个线程之前完成执行。例如：

Thread t1 = new Thread(new Runnable() {
    public void run() {
        // 任务1
    }
});
Thread t2 = new Thread(new Runnable() {
    public void run() {
        try {
            t1.join();  // 等待t1线程完成
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 任务2
    }
});
t1.start();
t2.start();

2. 并行执行：在这种模式下，多个线程同时执行，以提高程序的执行效率。Thread.join()可以用于等待某个线程完成，以便在该线程完成后执行其他操作。例如：

Thread t1 = new Thread(new Runnable() {
    public void run() {
        // 任务1
    }
});
Thread t2 = new Thread(new Runnable() {
    public void run() {
        // 任务2
    }
});
t1.start();
t2.start();
try {
    t1.join();  // 等待t1线程完成
} catch (InterruptedException e) {
    e.printStackTrace();
}
// 在这里执行依赖于t1的任务

3. 线程池：在这种模式下，使用线程池来管理线程，以提高资源利用率和性能。Thread.join()可以用于等待线程池中的某个线程完成。例如：

ExecutorService executor = Executors.newFixedThreadPool(2);
Future<?> future1 = executor.submit(new Runnable() {
    public void run() {
        // 任务1
    }
});
Future<?> future2 = executor.submit(new Runnable() {
    public void run() {
        // 任务2
    }
});
try {
    future1.get();  // 等待future1对应的线程完成
    future2.get();  // 等待future2对应的线程完成
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}
executor.shutdown();

4. 生产者-消费者模式：在这种模式下，一个或多个生产者线程生成数据，一个或多个消费者线程处理数据。Thread.join()可以用于确保数据在生产者和消费者之间正确地传递和处理。例如：

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

Thread producer = new Thread(new Runnable() {
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                queue.put(i);  // 生产数据
                Thread.sleep(100);  // 模拟生产延迟
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});

Thread consumer = new Thread(new Runnable() {
    public void run() {
        try {
            while (true) {
                Integer item = queue.take();  // 消费数据
                System.out.println("Consumed: " + item);
                Thread.sleep(200);  // 模拟消费延迟
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});

producer.start();
consumer.start();
producer.join();  // 等待生产者线程完成

这些模式只是Java并发编程中的一部分，实际上还有更多的模式和组合方式可以使用Thread.join()来实现线程间的协作。