java 如何等待线程完毕

2025-06-09 13:04:35

Java中等待线程完毕的方法有：使用Thread.join()方法、使用ExecutorService和Future、使用CountDownLatch、使用CyclicBarrier。其中，最常用和直观的方法是使用Thread.join()方法，它可以使当前线程等待直到目标线程结束。通过调用目标线程的join()方法，当前线程会进入等待状态，直到目标线程完成。这个方法非常适合简单场景下的线程同步。本文将详细介绍这些方法的使用及其适用场景。

一、Thread.join()方法

Thread.join() 是Java中最直接的线程等待方法。通过调用目标线程的join()方法，当前线程会进入等待状态，直到目标线程完成。

使用Thread.join()的基本方法

Thread.join()方法有三种形式：join()、join(long millis)和join(long millis, int nanos)。最常用的是join()，它会无限期地等待目标线程结束。

public class JoinExample {

public static void main(String[] args) {

Thread thread = new Thread(() -> {

try {

Thread.sleep(2000); // 模拟工作

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("Thread has finished execution");

});

thread.start();

try {

thread.join(); // 等待目标线程结束

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("Main thread has finished execution");

}

在这个例子中，主线程将等待目标线程完成后再继续执行。

使用join(long millis)和join(long millis, int nanos)

有时我们不希望无限期等待，可以使用带超时的join方法。它们允许设置一个最长等待时间。

public class JoinWithTimeoutExample {

public static void main(String[] args) {

Thread thread = new Thread(() -> {

try {

Thread.sleep(5000); // 模拟工作

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("Thread has finished execution");

});

thread.start();

try {

thread.join(2000); // 最多等待2秒

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("Main thread has finished execution");

}

在这个例子中，主线程最多等待目标线程2秒。如果目标线程在2秒内没有完成，主线程将继续执行。

二、使用ExecutorService和Future

ExecutorService 提供了一种更高级的线程管理方式。通过提交任务给ExecutorService，我们可以获得一个Future对象，使用这个对象可以等待任务完成。

基本用法

通过调用Future的get()方法，当前线程将等待直到任务完成。

import java.util.concurrent.*;

public class FutureExample {

public static void main(String[] args) {

ExecutorService executor = Executors.newSingleThreadExecutor();

Callable task = () -> {

Thread.sleep(2000); // 模拟工作

return "Task completed";

};

Future future = executor.submit(task);

try {

String result = future.get(); // 等待任务完成

System.out.println(result);

} catch (InterruptedException | ExecutionException e) {

e.printStackTrace();

}

executor.shutdown();

System.out.println("Main thread has finished execution");

}

在这个例子中，主线程将等待任务完成，并获取任务的结果。

使用带超时的get方法

类似于join方法，Future的get方法也可以设置超时。

import java.util.concurrent.*;

public class FutureWithTimeoutExample {

public static void main(String[] args) {

ExecutorService executor = Executors.newSingleThreadExecutor();

Callable task = () -> {

Thread.sleep(5000); // 模拟工作

return "Task completed";

};

Future future = executor.submit(task);

try {

String result = future.get(2, TimeUnit.SECONDS); // 最多等待2秒

System.out.println(result);

} catch (InterruptedException | ExecutionException | TimeoutException e) {

e.printStackTrace();

}

executor.shutdown();

System.out.println("Main thread has finished execution");

}

在这个例子中，主线程最多等待任务2秒。如果任务在2秒内没有完成，将抛出TimeoutException。

三、使用CountDownLatch

CountDownLatch 是一个同步辅助类，它允许一个或多个线程等待，直到其他线程完成一系列操作。

基本用法

CountDownLatch初始化时需要一个计数值，表示需要等待的操作数。调用await()方法的线程将一直等待，直到计数值变为0。

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {

public static void main(String[] args) throws InterruptedException {

int numberOfThreads = 3;

CountDownLatch latch = new CountDownLatch(numberOfThreads);

for (int i = 0; i < numberOfThreads; i++) {

new Thread(() -> {

try {

Thread.sleep(2000); // 模拟工作

System.out.println("Thread has finished execution");

} catch (InterruptedException e) {

e.printStackTrace();

} finally {

latch.countDown(); // 计数减1

}

}).start();

}

latch.await(); // 等待所有线程完成

System.out.println("Main thread has finished execution");

}

在这个例子中，主线程将等待所有工作线程完成后再继续执行。

四、使用CyclicBarrier

CyclicBarrier 是另一种同步辅助类，它允许一组线程相互等待，直到所有线程都达到一个公共的屏障点。

基本用法

CyclicBarrier需要一个parties参数，表示屏障点需要等待的线程数。

import java.util.concurrent.BrokenBarrierException;

import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {

public static void main(String[] args) {

int numberOfThreads = 3;

CyclicBarrier barrier = new CyclicBarrier(numberOfThreads, () -> System.out.println("All threads have reached the barrier"));

for (int i = 0; i < numberOfThreads; i++) {

new Thread(() -> {

try {

Thread.sleep(2000); // 模拟工作

System.out.println("Thread has finished execution and is waiting at the barrier");

barrier.await(); // 等待其他线程

} catch (InterruptedException | BrokenBarrierException e) {

e.printStackTrace();

}

}).start();

}

在这个例子中，所有工作线程将等待彼此都完成后再继续执行。

五、总结

在Java中，有多种方法可以等待线程完毕。Thread.join() 是最简单直接的方法，适用于简单场景。ExecutorService和Future 提供了更高级的任务管理和等待机制，适用于复杂的多线程任务。CountDownLatch 和 CyclicBarrier 是高级的同步工具，适用于需要多个线程协调工作的场景。

通过了解这些方法的适用场景和使用方法，开发者可以选择最合适的方法来实现线程同步，确保程序的正确性和高效性。