Java主线程等待子线程、线程池

public class TestThread extends Thread
{
	public void run()
	{
		System.out.println(this.getName() + "子线程开始");
		try
		{
			// 子线程休眠五秒
			Thread.sleep(5000);
		}
		catch (InterruptedException e)
		{
			e.printStackTrace();
		}
		System.out.println(this.getName() + "子线程结束");
	}
}

首先是一个线程,它执行完成需要5秒。


1、主线程等待一个子线程

public class Main
{
	public static void main(String[] args)
	{
		long start = System.currentTimeMillis();
		
		Thread thread = new TestThread();
		thread.start();
		
		long end = System.currentTimeMillis();
		System.out.println("子线程执行时长:" + (end - start));
	}
}

在主线程中,需要等待子线程执行完成。但是执行上面的main发现并不是想要的结果:

子线程执行时长:0

Thread-0子线程开始

Thread-0子线程结束

很明显主线程和子线程是并发执行的,主线程并没有等待。

对于只有一个子线程,如果主线程需要等待子线程执行完成,再继续向下执行,可以使用Thread的join()方法。join()方法会阻塞主线程继续向下执行。

public class Main
{
	public static void main(String[] args)
	{
		long start = System.currentTimeMillis();
		
		Thread thread = new TestThread();
		thread.start();
		
		try
		{
			thread.join();
		}
		catch (InterruptedException e)
		{
			e.printStackTrace();
		}
		
		long end = System.currentTimeMillis();
		System.out.println("子线程执行时长:" + (end - start));
	}
}

执行结果:

Thread-0子线程开始

Thread-0子线程结束

子线程执行时长:5000

注意:join()要在start()方法之后调用。

2、主线程等待多个子线程

比如主线程需要等待5个子线程。这5个线程之间是并发执行。

public class Main
{
	public static void main(String[] args)
	{
		long start = System.currentTimeMillis();
		
		for(int i = 0; i < 5; i++)
		{
			Thread thread = new TestThread();
			thread.start();
			
			try
			{
				thread.join();
			}
			catch (InterruptedException e)
			{
				e.printStackTrace();
			}
		}
		
		long end = System.currentTimeMillis();
		System.out.println("子线程执行时长:" + (end - start));
	}
}

在上面的代码套上一个for循环,执行结果:

Thread-0子线程开始

Thread-0子线程结束

Thread-1子线程开始

Thread-1子线程结束

Thread-2子线程开始

Thread-2子线程结束

Thread-3子线程开始

Thread-3子线程结束

Thread-4子线程开始

Thread-4子线程结束

子线程执行时长:25000

由于thread.join()阻塞了主线程继续执行,导致for循环一次就需要等待一个子线程执行完成,而下一个子线程不能立即start(),5个子线程不能并发。

要想子线程之间能并发执行,那么需要在所有子线程start()后,在执行所有子线程的join()方法。

public class Main
{
	public static void main(String[] args)
	{
		long start = System.currentTimeMillis();
		
		List<Thread> list = new ArrayList<Thread>();
		for(int i = 0; i < 5; i++)
		{
			Thread thread = new TestThread();
			thread.start();
			list.add(thread);
		}
		
		try
		{
			for(Thread thread : list)
			{
				thread.join();
			}
		}
		catch (InterruptedException e)
		{
			e.printStackTrace();
		}
		
		long end = System.currentTimeMillis();
		System.out.println("子线程执行时长:" + (end - start));
	}
}

执行结果:

Thread-0子线程开始

Thread-3子线程开始

Thread-1子线程开始

Thread-2子线程开始

Thread-4子线程开始

Thread-3子线程结束

Thread-0子线程结束

Thread-2子线程结束

Thread-1子线程结束

Thread-4子线程结束

子线程执行时长:5000

3、主线程等待多个子线程(CountDownLatch实现)

CountDownLatch是java.util.concurrent中的一个同步辅助类,可以把它看做一个倒数计数器,就像神舟十号发射时倒数:10,9,8,7….2,1,0,走你。初始化时先设置一个倒数计数初始值,每调用一次countDown()方法,倒数值减一,await()方法会阻塞当前进程,直到倒数至0。

同样还是主线程等待5个并发的子线程。修改上面的代码,在主线程中,创建一个初始值为5的CountDownLatch,并传给每个子线程,在每个子线程最后调用countDown()方法对倒数器减1,当5个子线程等执行完成,那么CountDownLatch也就倒数完成,主线程调用await()方法等待5个子线程执行完成。

修改MyThread接收传入的CountDownLatch:

public class TestThread extends Thread
{
	private CountDownLatch countDownLatch;
	
	public TestThread(CountDownLatch countDownLatch)
	{
		this.countDownLatch = countDownLatch;
	}

	public void run()
	{
		System.out.println(this.getName() + "子线程开始");
		try
		{
			// 子线程休眠五秒
			Thread.sleep(5000);
		}
		catch (InterruptedException e)
		{
			e.printStackTrace();
		}
		
		// 倒数器减1
		countDownLatch.countDown();
		
		System.out.println(this.getName() + "子线程结束");
	}
}

修改main:

public class Main
{
	public static void main(String[] args)
	{
		long start = System.currentTimeMillis();
		
		// 创建一个初始值为5的倒数计数器
		CountDownLatch countDownLatch = new CountDownLatch(5);
		for(int i = 0; i < 5; i++)
		{
			Thread thread = new TestThread(countDownLatch);
			thread.start();
		}
		
		try
		{
			// 阻塞当前线程,直到倒数计数器倒数到0
			countDownLatch.await();
		}
		catch (InterruptedException e)
		{
			e.printStackTrace();
		}
		
		long end = System.currentTimeMillis();
		System.out.println("子线程执行时长:" + (end - start));
	}
}

执行结果:

Thread-0子线程开始

Thread-2子线程开始

Thread-1子线程开始

Thread-3子线程开始

Thread-4子线程开始

Thread-2子线程结束

Thread-4子线程结束

Thread-1子线程结束

Thread-0子线程结束

Thread-3子线程结束

子线程执行时长:5000

注意:如果子线程中会有异常,那么countDownLatch.countDown()应该写在finally里面,这样才能保证异常后也能对计数器减1,不会让主线程永远等待。

另外,await()方法还有一个实用的重载方法:public booleanawait(long timeout, TimeUnit unit),设置超时时间。

例如上面的代码,想要设置超时时间10秒,到了10秒无论是否倒数完成到0,都会不再阻塞主线程。返回值是boolean类型,如果是超时返回false,如果计数到达0没有超时返回true。

// 设置超时时间为10秒
boolean timeoutFlag = countDownLatch.await(10,TimeUnit.SECONDS);
if(timeoutFlag)
{
	System.out.println("所有子线程执行完成");
}
else
{
	System.out.println("超时");
}

4、主线程等待线程池

Java线程池java.util.concurrent.ExecutorService是很好用的多线程管理方式。ExecutorService的一个方法boolean awaitTermination(long timeout, TimeUnit unit),即阻塞主线程,等待线程池的所有线程执行完成,用法和上面所说的CountDownLatch的public boolean await(long timeout,TimeUnit unit)类似,参数设置一个超时时间,返回值是boolean类型,如果超时返回false,如果线程池中的线程全部执行完成,返回true。

由于ExecutorService没有类似CountDownLatch的无参数的await()方法,只能通过awaitTermination来实现主线程等待线程池。

public class Main
{
	public static void main(String[] args)
	{
		long start = System.currentTimeMillis();
		
		// 创建一个同时允许两个线程并发执行的线程池
		ExecutorService executor = Executors.newFixedThreadPool(2);
		for(int i = 0; i < 5; i++)
		{
			Thread thread = new TestThread();
			executor.execute(thread);
		}
		executor.shutdown();
		
		try
		{
			// awaitTermination返回false即超时会继续循环,返回true即线程池中的线程执行完成主线程跳出循环往下执行,每隔10秒循环一次
			while (!executor.awaitTermination(10, TimeUnit.SECONDS));
		}
		catch (InterruptedException e)
		{
			e.printStackTrace();
		}
		
		long end = System.currentTimeMillis();
		System.out.println("子线程执行时长:" + (end - start));
	}
}

执行结果:

Thread-0子线程开始

Thread-1子线程开始

Thread-0子线程结束

Thread-2子线程开始

Thread-1子线程结束

Thread-3子线程开始

Thread-2子线程结束

Thread-4子线程开始

Thread-3子线程结束

Thread-4子线程结束

子线程执行时长:15000

另外,while(!executor.isTerminated())也可以替代上面的while (!executor.awaitTermination(10,TimeUnit.SECONDS)),isTerminated()是用来判断线程池是否执行完成。但是二者比较我认为还是awaitTermination更好,它有一个超时时间可以控制每隔多久循环一次,而不是一直在循环来消耗性能。


作者:叉叉哥 转载请注明出处:http://blog.youkuaiyun.com/xiao__gui/article/details/9213413


<think>好的,我现在需要帮助用户解决Java主线程如何等待线程池执行完成的问题。用户提到了join方法、shutdown和awaitTermination,我需要结合这些关键词给出清晰的解答。首先,我应该回忆一下Java线程的相关知识,特别是线程池的管理和同步机制。 首先,用户提到的join方法。我记得Thread类的join方法可以让主线程等待子线程结束,但线程池中的线程通常是通过ExecutorService管理的,不能直接获取到每个线程的引用,所以直接使用join可能不太适用。这点需要说明清楚,避免用户混淆。 然后是shutdown和awaitTermination。线程池的shutdown方法会启动有序关闭,不再接受新任务,但已提交的任务会继续执行。而awaitTermination则是阻塞主线程,直到所有任务完成或者超时。不过要注意,shutdown之后必须调用awaitTermination才能真正等待,否则主线程可能立即继续执行。同时,需要处理可能的InterruptedException异常。 接下来,用户可能没有提到的其他方法,比如CountDownLatch。这是并发工具类中的一个同步辅助器,可以在每个任务完成时递减计数器,主线程等待计数器归零。这种方法更灵活,尤其适用于需要明确知道所有任务完成的场景。此外,Future的get方法也可以用来等待任务完成,但如果是多个任务的话,可能需要遍历所有Future对象,逐一调用get,这可能会比较繁琐,或者使用invokeAll方法。 还有,使用shutdown结合isTerminated轮询检查的方法,虽然不推荐,但在某些情况下可能适用。需要指出这种方法的缺点,比如忙等待可能消耗CPU资源。 现在需要整理这些方法,按推荐的顺序进行说明,可能从最基础的Thread.join到高级工具类。但考虑到用户的问题是关于线程池的,应该重点放在ExecutorService的方法和CountDownLatch上。 需要注意的是,线程池中的线程默认是守护线程,如果主线程等待的话,可能会提前退出,导致子线程未完成就被终止。因此,正确的等待机制非常重要。 另外,需要给出示例代码,帮助用户理解如何具体实现。比如使用awaitTermination时,先调用shutdown,然后循环调用awaitTermination,直到返回true或者超时。或者使用CountDownLatch,在每个任务完成时调用countDown()。 可能还需要比较不同方法的优缺点,比如使用CountDownLatch可以更精确地控制,而awaitTermination依赖于线程池的正确关闭。同时,要提醒用户处理异常情况,比如任务执行过程中抛出异常,是否会影响等待机制。 最后,生成相关问题,比如如何判断线程池是否完成,或者如何处理任务中的异常,这些都能帮助用户进一步学习。</think>在Java中,主线程等待线程池执行完毕主要有以下四种实现方式,按推荐优先级排序: ### 一、使用`awaitTermination`方法(推荐) 1. 调用`shutdown()`关闭线程池 2. 配合`awaitTermination()`实现等待 ```java ExecutorService executor = Executors.newFixedThreadPool(4); // 提交任务... executor.shutdown(); // 停止接收新任务 try { // 循环等待直到所有任务完成 while (!executor.awaitTermination(60, TimeUnit.SECONDS)) { System.out.println("等待任务完成..."); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } ``` **优势**:官方推荐方式,可设置超时时间避免无限阻塞[^2] ### 二、使用`CountDownLatch`(精确控制) 1. 创建计数器(任务数量为初始值) 2. 每个任务完成后计数器减1 ```java CountDownLatch latch = new CountDownLatch(10); ExecutorService executor = Executors.newFixedThreadPool(4); for (int i = 0; i < 10; i++) { executor.submit(() -> { try { // 执行任务... } finally { latch.countDown(); // 必须放在finally块 } }); } try { latch.await(); // 主线程等待 } catch (InterruptedException e) { Thread.currentThread().interrupt(); } ``` **特点**:精确控制等待的任务数量,适合已知任务总数的情况[^3] ### 三、使用`Future`+`get()`方法 ```java List<Future<?>> futures = new ArrayList<>(); ExecutorService executor = Executors.newFixedThreadPool(4); for (int i = 0; i < 10; i++) { futures.add(executor.submit(() -> { // 执行任务... })); } try { for (Future<?> future : futures) { future.get(); // 阻塞获取结果 } } catch (ExecutionException | InterruptedException e) { // 异常处理 } ``` ### 四、不推荐的方式:`join`方法 $$注意:线程池中的工作线程无法直接获取Thread对象,因此join方法不适用于线程池场景$$ ### 对比表格 | 方法 | 适用场景 | 超时控制 | 异常处理 | 资源释放 | |--------------------|-------------------------|--------|--------|--------| | awaitTermination | 通用场景 | 支持 | 自动 | 自动 | | CountDownLatch | 精确控制任务数量 | 支持 | 手动 | 手动 | | Future.get() | 需要获取任务结果 | 支持 | 自动 | 自动 | | isTerminated轮询 | 需要实时监控 | 支持 | 手动 | 自动 | **最佳实践建议**:优先使用`awaitTermination`+`shutdown`组合,需要获取任务结果时配合`Future`使用,精确控制任务完成数量时使用`CountDownLatch`[^4]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值