线程池(newFixedThreadPool)、子线程回应(CountDownLatch)

线程池与CountDownLatch示例
最新推荐文章于 2022-12-28 10:45:00 发布
原创 最新推荐文章于 2022-12-28 10:45:00 发布 · 486 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#多线程

本文介绍如何使用Java线程池newFixedThreadPool及CountDownLatch实现多线程任务管理。通过具体代码示例展示了如何创建固定大小的线程池执行多个任务，并确保所有子线程完成后执行后续操作。
原文地址：[url]http://blog.youkuaiyun.com/conquer0715/article/details/9000548[/url]
利用线程池newFixedThreadPool实现多线程，并通过CountDownLatch实现等待所有子线程结束后执行主线程。

//所有子线程执行完毕后执行主线程
static void threadsCall() {
ExecutorService threadPool = Executors.newFixedThreadPool(10);
int threadTaskNum = 5;
final CountDownLatch answers = new CountDownLatch(threadTaskNum);//同步计数器
for (int i = 0; i < threadTaskNum; i++) {
threadPool.execute(new Runnable() {
@Override
public void run() {
try {
System.out.println("线程" + Thread.currentThread().getName() + " 开始处理任务 ...");
Thread.sleep((long) (Math.random() * 5000));
System.out.println("线程" + Thread.currentThread().getName() + " 处理完毕，汇报结果！");
answers.countDown();
} catch (Exception e) {}
}
});
}
threadPool.shutdown();// 线程池不再接受新任务，全部任务结束后保证线程池退出运行
try {
answers.await();// 在所有子线程结束前保持阻塞
} catch (InterruptedException e) {}
System.out.println("线程" + Thread.currentThread().getName() + "已收到所有汇报结果");
}
结果：

线程pool-1-thread-1 开始处理任务 ...
线程pool-1-thread-2 开始处理任务 ...
线程pool-1-thread-3 开始处理任务 ...
线程pool-1-thread-4 开始处理任务 ...
线程pool-1-thread-5 开始处理任务 ...
线程pool-1-thread-5 处理完毕，汇报结果！
线程pool-1-thread-2 处理完毕，汇报结果！
线程pool-1-thread-3 处理完毕，汇报结果！
线程pool-1-thread-1 处理完毕，汇报结果！
线程pool-1-thread-4 处理完毕，汇报结果！
线程main已收到所有汇报结果
CountDownLatch与线程池共用，主线程等待多个子线程执行完再继续执行
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
11-12 1856
public class CollectionSyn { public static void main(String[] args) { CollectionSyn collectionSyn = new CollectionSyn(); //1 //collectionSyn.f1(); //2 /* ...
线程池+CountDownLatch 处理大集合
zhanghe687的博客
03-16 2718
场景：有一个需求：首先从数据库中取出上千条数据，然后需要逐条对数据进行分析，例如分析情感/是否重复等多项分析。 解决：将取出来的上千条，分批+多线程处理。 public class CountDownLatchTest { public static void main(String[] args) { ArrayList<String> list = new ArrayList<String>(); for (int i = 0;
CountDownLatch、CyclicBarrier、Executors.newFixedThreadPool
Tastill的博客
04-29 272
Java并发编程之闭锁与栅栏 对Executors.newFixedThreadPool，CountDownLatch的个人初步了解
java线程池newFixedThreadPool的创建和锁存器CountDownLatch的简单使用
weixin_42241626的博客
04-28 482
创建实体类 Test package com.test.pojo; import java.io.Serializable; public class Test implements Serializable { private int id; private String name; private int age; public int getId() ...
对Executors.newFixedThreadPool，CountDownLatch的个人初步了解
simon_it的博客
08-30 2017
Executors.newFixedThreadPool ExecutorService是Executor直接的扩展接口，也是最常用的线程池接口，我们通常见到的线程池定时任务线程池都是它的实现类。 Executors.newFixedThreadPool一个固定大小的线程池 Executors.newFixedThreadPool（4）好比如一个车间里面只能允许4个人的容量，然后4个人一起工...
scala线程demo-newFixedThreadPool
cache007的专栏
01-28 1313
object FixedThread {   def main(args: Array[String]): Unit = {     val threads = Executors.newFixedThreadPool(3);     for (i       threads.execute(new MyThread("fix-thread(" + i + ")"))    
使用countdownlatch和线程池fixedThreadPool实现任务的分发执行
健康平安的活着的专栏
01-07 1550
业务逻辑要求：每次调用多个任务，将任务分发给多个子线程，实现并行执行。本代码使用缓存线程池cacheThreadPool初始化多个线程，使用countdownlatch做子线程的计数控制，当子线程执行完，释放执行权，交给主线程，开始下一轮的执行。 话不多说：上代码 package com.test.thread; import java.util.ArrayList; import jav...
在Java线程池中 主线程等待子线程完成任务 并返回
telltao的博客
07-08 2020
Java创建一个固定长度的线程池执行业务逻辑完成 创建一个固定长度的线程池 /** * <pre> * Create By Liu Tao * 创建一个线程池，该线程池重用在共享无界队列上运行的固定数量的线程。 * 在任何时候，大多数Threads线程都是活动的处理任务。 * 如果在所有线程都处于活动状态时提交其他任务，它们将在...
Java多线程--等待所有子线程执行完的五种方法.docx
09-14
在Java多线程编程中，有时我们需要确保所有子线程执行完毕后再进行后续操作，例如在并发测试、数据聚合或资源清理等场景。本篇文章将详细介绍五种在Java中等待所有子线程执行完的方法。 ### 方法一：使用`sleep`...
多线程-子线程与主线程协同处理
qq_34930421的博客
12-18 1246
多线程-子线程与主线程协同处理 此次的业务需求是一次提交一批数据入库，数据量会比较大。在入库过程中因为业务需求的原因，没有使用批处理入库，而是遍历循环每一条数据先执行删除（删除原本库里的老数据）再执行新增操作。当一批中的所有数据都操作完且没有异常后执行commit操作，若有任意一条有异常则都会执行rollback操作。因为处理较慢，所以考虑到使用多线程入库。但使用多线程后因为事务只能作用域loca...
java 线程池newFixedThreadPool
diaoxie5099的博客
07-25 196
工作中遇到一个这样的情况，List中的元素要每个遍历出来，然后作为参数传给后面通过spark做数据处理，元素太多，一个一个的遍历速度太慢，于是考虑使用多线程，代码如下：（已删除部分代码） 想了解更多线程池的内容，可以参考链接：https://blog.csdn.net/aa1215018028/article/details/82814192 package com.kong.t...
线程池newFixedThreadPool
weixin_43543184的博客
07-22 335
创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。在任意点，在大多数 nThreads 线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池中的线程将一直存在。 ...
Java多线程CountDownLatch与线程池ThreadPool的使用
Dream it Possible
03-22 8465
一. CountDownLatch是什么 &nbsp;&nbsp;&nbsp;&nbsp;CountDownLatch是一个同步工具类，它允许一个或多个线程等待，直到在其他线程中执行的一组操作完成。 &nbsp;&nbsp;&nbsp;&nbsp;CountDownLatch是通过一个计数器实现的，计数器的初始值为线程的数量，这是一个一次性现象，计数不能重置。如果需要重置计数，可以考虑使用cy...
在项目中使用——newFixedThreadPool线程池
理想主义的花最终会盛开在浪漫主义的土壤里，我的热情永远不会熄灭在现实的平凡之中，我们终将上岸，阳光万里。
12-28 8031
本篇博客的目的是让大家能够熟练的简单运用newFixedThreadPool线程池并且能够运用到具体的 项目开发中。通过本篇博客你将完全掌握newFixedThreadPool线程池的基本运用，使用多线程进行开发。newFixedTheadPool是六种常用线程池的其中一种，newFixedThreadPool的特点是他的核心线程数和最大线程数是一致的，并且是一个固定线程数的线程池。线程池的大小一旦达到最大值后，再有新的任务提交时则放入无界阻塞队列中，等到有线程空闲时，再从队列中取出任务继续执行。
Java线程池ThreadPoolExecutor详解和CountDownLatch的使用
进击的豌豆的博客
06-08 2658
多线程
CountDownLatch多任务处理利器
Discovery的专栏
04-25 568
CountDownLatch 是由java并发包提供的一个同步计数器，从字面意义上去理解可以分成两部分CountDown 和 Latch，CountDown就是计数的意思，Latch是门闩，这个同步工具就是通过保证多线程环境下，通过门闩限制主线程执行，子线程执行后计数减1，直到减为0，门闩打开，主线程执行。 场景一： ...
ExecutorService线程池详解
qiaziliping的博客
04-10 1807
对线程池 “池”的理解 可以理解为工厂，如果工厂生产斧头，小王从工厂借了一把，当小王用完了，还给工厂，之后小李也可以借去用 复用已有资源 控制资源总量 你一个任务过来了，我发现池子里有没事干并且还活着的线程，来，拿去用，我也不用费事给你创建一条线程了，要知道线程的创建和销毁可都是麻烦事 你一个任务过来了，我发现池子的线程都在忙，并且现在池子的线程已经太多了，在不限制下去就要内存溢出了...
线程池 超时时间 等待线程池中的线程完成所有任务
memory的博客
01-10 3993
newFixedThreadPool 创建一个固定大小的线程池。 shutdown()：用于关闭启动线程，如果不调用该语句，jvm不会关闭。 awaitTermination()：用于等待子线程结束，再继续执行下面的代码。该例中我设置一直等着子线程结束。 isTerminated当调用shutdown()方法后，并且所有提交的任务完成后返回为true interrupt() 与 canc...
Spark利用多线程并发提交多个任务
a805814077的博客
05-28 5635
spark并行提交多个任务的方法
java如何等待多个异步子线程结束
最新发布
08-20
<think>我们正在讨论Java中如何等待多个异步启动的子线程执行结束。根据引用，有几种常见方法：Thread.join(), CountDownLatch, 以及使用Future和线程池（如ExecutorService）结合。 用户意图明确：需要协调多个子线程执行完毕后再继续主线程。 参考引用： [^1] 提到了使用sleep，但这不是可靠的方法，因为无法精确控制。 [^2] 提到使用Thread.join()，这是基础方法，但需要手动管理每个线程。 [^3] 展示了CountDownLatch的使用，这是更现代的并发工具，可以设置一个计数器，每个线程完成时计数器减一，主线程通过await()等待计数器归零。 [^4] 展示了使用Future和检查所有Future是否完成，并且可以设置超时。 因此，我们主要介绍三种方法： 1. Thread.join() 2. CountDownLatch 3. ExecutorService 配合 Future（或使用CompletableFuture） 此外，我们还可以提到Java 7引入的Fork/Join框架和Java 8的CompletableFuture，但考虑到问题要求等待多个异步启动的子线程，我们重点放在前三种。 注意：异步启动的子线程，意味着这些线程已经通过start()方法启动了。 我们将分别介绍这三种方法，并给出代码示例。 注意：代码示例中，我们使用Runnable来创建线程，实际中也可以使用Callable。 步骤： 1. 使用Thread.join()：主线程依次调用每个线程对象的join()方法，这样主线程会阻塞直到该线程结束。 2. 使用CountDownLatch：创建一个CountDownLatch对象，计数初始化为子线程数量。每个子线程在结束时调用countDown()。主线程调用await()等待。 3. 使用ExecutorService和Future：将子线程提交给线程池，得到Future对象列表。然后遍历Future列表，调用get()方法（会阻塞直到任务完成）或者使用isDone()检查（但需要循环，如引用[4]所示，但更推荐使用get()，因为get()会阻塞直到完成，或者使用invokeAll）。 但是注意：如果使用ExecutorService，我们通常不会直接使用Thread对象，而是提交任务。如果用户已经用Thread启动了线程，那么就不能再用ExecutorService管理了。因此，我们需要根据用户创建线程的方式来选择。 由于用户提到“异步启动的子线程”，我们假设用户已经通过new Thread().start()启动了多个线程。那么在这种情况下，我们可以使用Thread.join()或CountDownLatch，而ExecutorService通常用于通过线程池提交任务的情况。 因此，我们主要展示前两种方法，第三种方法可以作为另一种思路（如果用户愿意改用线程池管理任务）。 下面我们开始组织回答。</think>在 Java 中等待多个异步启动的子线程执行结束，有以下三种常用方法： --- ### 1. **使用 `Thread.join()`（基础方法）** 主线程依次调用每个子线程的 `join()` 方法，阻塞等待所有线程结束。 ```java public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread(() -> System.out.println("子线程1完成")); Thread t2 = new Thread(() -> System.out.println("子线程2完成")); t1.start(); // 异步启动 t2.start(); // 异步启动 t1.join(); // 阻塞等待 t1 结束 t2.join(); // 阻塞等待 t2 结束 System.out.println("所有子线程执行完毕，主线程继续"); } ``` **优点**：简单直接。 **缺点**：需手动管理每个线程，扩展性差[^2]。 --- ### 2. **使用 `CountDownLatch`（推荐方法）** 通过计数器实现同步，主线程调用 `await()` 阻塞，子线程完成时调用 `countDown()` 减少计数。 ```java public static void main(String[] args) throws InterruptedException { int threadCount = 3; CountDownLatch latch = new CountDownLatch(threadCount); // 初始化计数器 for (int i = 0; i < threadCount; i++) { new Thread(() -> { try { System.out.println("子线程执行任务..."); Thread.sleep(1000); } finally { latch.countDown(); // 计数器减1 } }).start(); } latch.await(); // 阻塞直到计数器归零 System.out.println("所有子线程执行完毕，主线程继续"); } ``` **优点**：解耦线程管理，支持动态线程数量[^3]。 --- ### 3. **使用 `ExecutorService` 和 `Future`（线程池管理）** 通过线程池提交任务，主线程遍历 `Future` 列表并调用 `get()` 阻塞等待结果。 ```java public static void main(String[] args) throws Exception { ExecutorService executor = Executors.newFixedThreadPool(3); List<Future<?>> futures = new ArrayList<>(); for (int i = 0; i < 3; i++) { futures.add(executor.submit(() -> { System.out.println("子线程执行任务..."); Thread.sleep(1000); return null; })); } // 阻塞等待所有任务完成 for (Future<?> future : futures) { future.get(); // 阻塞直到当前任务完成 } executor.shutdown(); System.out.println("所有子线程执行完毕，主线程继续"); } ``` **优点**：统一管理线程资源，支持返回值[^4]。 --- ### **总结对比** | **方法** | **适用场景** | **扩展性** | **复杂度** | |--------------------|----------------------------------|------------|------------| | `Thread.join()` | 线程数量固定且较少 | 低 | 简单 | | `CountDownLatch` | 动态线程数量，无需返回值 | 高 | 中等 | | `ExecutorService` | 需线程池管理或任务返回值 | 高 | 较高 | > **提示**： > - 若需超时控制，可使用 `latch.await(10, TimeUnit.SECONDS)` 或 `future.get(10, TimeUnit.SECONDS)`[^4]。 > - 避免使用 `Thread.sleep()` 轮询检查（不可靠且浪费资源）[^1]。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值