主线程等待子线程执行完再执行，几种实现方式性能分析比较

最新推荐文章于 2024-02-22 13:33:56 发布
原创 最新推荐文章于 2024-02-22 13:33:56 发布 · 419 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring boot

本文分析了在线程数量不同的情况下，CyclicBarrier与join两种线程同步方式的性能表现。研究发现，在线程数量较少时，CyclicBarrier在效率上占据优势；而当线程数量超过10000时，join方法展现出更好的耗时控制。

直接上图：

综上图分析，故可得出初步结论，在线程数量较少的情况下，CyclicBarrier略占优，当线程数量大于10000的时候，join的方式反而比较节省耗时。 

多线程编程全攻略：提升性能与线程安全的必备知识
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
10-14 10万+
介绍多线程编程的相关概念、同步机制以及无锁编程。从线程的基础概念出发，包括逻辑线程和硬件线程的比较，以及线程、核心和函数的关系。随后，我们探讨了多线程编程的基本原则，包括时间分片、上下文切换、线程安全函数和可重入函数等。接着，我们讨论了为什么需要多线程同步、什么情况需要进行同步以及多线程同步的方式，包括串行化、原子操作和锁等。我们还深入研究了非阻塞的无锁同步机制，如CAS循环和无锁数据结构。最后，我们解释了程序序、内存序、乱序执行、存储缓冲区和失效队列等概念，以帮助更好地理解多线程编程。
协程通过引入微线程的方式，实现了在单个线程中同时执行多个任务的功能，从而可以充分利用系统资源提升性能。
AI天才研究院
07-28 1609
在计算机科学领域，协程（Coroutine）是一个编程概念。它使得一个线程里可以暂停运行，转而去执行另一个线程。协程能够极大地减少线程创建和切换开销，因为线程切换涉及到操作系统的 CPU 抢占、进程调度等额外开销。更加容易编写：协程允许更细粒度的并发，允许多任务共享内存，因此可以更简单地编写出正确、健壮的异步 I/O 模型。更高效率：由于协程可以在非抢占状态下执行，因此不用进行复杂的线程同步，调度，避免了锁竞争等问题，有效地提升了处理能力。
ExecutorService线程池处理for循环
【莉婶】的博客
02-11 3942
参考链接：https://blog.youkuaiyun.com/bufanrong/article/details/90295576 功能背景:为提高性能，需要异步执行一个list的数据。 多线程处理过程概述: 利用ExecutorService创建线程池，代码如下： int TOTAL_THREADS = 4;//线程数 //数据库中的1万条数据; List list =...
主线程等待子线程CountDownLatch springboot2.x
停止使用
03-21 2631
防止子线程没执行结束主线程就释放了 1.配置加上#设置线程池的线程数量 threads.number=42.设置一个定长线程池package cc.datebook.config;import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.Bean;
主线程等待子线程执行完毕再执行的几种方式
我的博客
02-22 3089
CyclicBarrier需要阻塞线程，ExecutorService每次都需要单独建立线程池执行任务，join()也是每个任务都需要单独建立线程执行，系统开销上会比较大。CyclicBarrier是所有线程执行完后一起等待，条件满足后所有线程再一起继续向下执行；ExecutorService是通过线程池方式实现程序等待的，它的原理是进入方法时初始化一个线程池，添加任务执行，然后执行关闭线程池，线程池会在所有线程任务执行完成后进行关闭，通过判断线程池是否关闭来判断程序的执行。
面试官：如何让主线程等待所有的子线程执行结束之后再执行
养歌的博客
01-12 5209
java 主线程等待所有子线程执行完毕在执行，在工作总往往会遇到异步去执行某段逻辑, 然后先处理其他事情, 处理完后再把那段逻辑的处理结果进行汇总（比如用户下单一个产品，后台会做一系列的处理，为了提高效率，每个处理都可以用一个线程来执行，所有处理完成了之后才会返回给用户下单成功）的场景, 这时候就需要使用线程了。 解决方法 sleep 用 sleep 方法，让主线程睡眠一段时间，让其它子线程先执行，虽然也是解决的方法，但是不推荐使用。 public class ThreadTest extends Thre
多线程中主线程等待所有子线程执行完再继续执行的解决方法
三人行必有我师,手写三行必有所悟
01-15 1万+
最近在做系统架构的时候，一个命令需要同时在多个分布节点上执行命令，但主处理又必须等所有节点执行回来后再继续处理，因此研究了一下多线程，现分享如下： 1）第1种方法，微软提供的标准教程: 利用 ManualResetEvent和WaitHandle.WaitAll: public class Fibonacci { public Fibonacci(int n, Man
iOS中延时执行的几种方式比较及汇总
08-28
在iOS开发中，有时我们需要将某些任务延迟一段时间后执行，比如等待用户操作、动画效果结束后执行后续逻辑等。...在性能和用户体验方面考虑，推荐使用GCD或`NSTimer`，特别是对于那些需要在特定线程执行的任务。
C#实现程序等待延迟执行的方法
09-03
在C#编程中，有时我们需要让程序在执行到某一点时暂停一段时间，然后再继续执行后续的代码，这种功能称为程序等待或延迟执行。这在各种场景下都很常见，比如模拟用户交互、避免过于频繁的网络请求等。在C#中，我们...
python从子线程中获得返回值的方法
09-19
在Python中，多线程是实现并发处理的一种常见方式。但在实际开发过程中，我们经常会遇到需要从子线程中获取数据的情况。由于线程对象本身并不直接支持返回值，因此需要采取一些特殊的方式来解决这个问题。 #### ...
C#利用子线程刷新主线程分享教程
09-05
本文将详细介绍C#利用子线程如何刷新主线程，需要了解更多的朋友可以参考下
主线程等待所有子线程结束的4种方法
qq_40774600的博客
03-10 6797
主线程等待所有子线程结束的4种方法，包括使用`CountDownLatch`、`CyclicBarrier`、`Future.get()`、`Completable.allOf()`。
详解synchronized关键字（无锁、偏向锁、轻量级锁（自旋锁）、重量级锁四种锁状态）-多线程与高并发
phs999的博客
09-26 1705
介绍CAS（compare and swap）、对象内存分布、markword、synchronized中锁的状态（无锁、偏向锁、轻量级锁、重量级锁）研究、Java Object Layout
SpringBoot线程池，@Async 注解。实现主线程等待所有子线程执行完毕再结束。
不受天磨非好汉，不遭人妒是庸才——着实着迷゛
08-17 8499
log.info("---主线程开始"); List<Future> futureList = new ArrayList<>(); List<VideoInfoDTO> videos = specsConfig.getVideos(); if (CollectionUtils.isNotEmpty(videos)) { videos.forEach(video ->{ ...
Java主线程等待所有子线程执行完毕再执行解决办法集
热门推荐
编故事的逗老师的专栏
09-06 1万+
Java主线程等待所有子线程执行完毕在执行，其实在我们的工作中经常的用到，比如说主线程要返回一个响应用户的值，但这个值得赋值过程是由过个子线程来完成的（模拟一个实际开发的情景），所以主线程必须等待子线程执行完毕，再响应用户；否则，响应用户的是一个无意义的值。 那么如何确保所有的子线程执行完毕了。一般的有如下方法： 1  让主线程等待，或着睡眠几分钟。用Thread.sleep()或者TimeU
让主线程等待子线程运行结束
weixin_44130608的博客
08-14 323
当需要主线程阻塞等待子线程运行的时候可以用这个方法，看了网络编程后，解决了困惑，为什么springbootweb启动后可以保持运行状态，大概就是里面有个周期线程池用来接受信号。
面试官：如何让主线程等待所有的子线程执行结束之后再执行？我懵了
阳阳的博客
09-09 7093
使用Thread的join方法 package com.qcy.testThreadFinish; /** * @author qcy * @create 2020/09/09 17:05:23 */ public class Case1 { public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread(() -> {
主线程wait等待子线程返回对象信息
u013905744的专栏
07-04 902
需求：假设一个线程（JarThread）正在从网络连接（用System.in模拟）中读取一个JAR归档文件。这个归档文件中第一项是清单文件（用‘/’标识结束）。另一个线程（MainThread）可能对这个清单文件的内容感兴趣，即使归档文件的其余部分尚不可用。对清单文件感兴趣的线程会创建一个定制的ManifestFile对象，将这个对象的引用传递给将要读取JAR归档文件的线程，并等待这个对象。读取归档文件的线程首先用流中的项填写ManifestFile，然后通知ManifestFile，再继续读取JAR归档文
并发编程之二：等待线程运行结束
weixin_43476824的博客
07-17 400
等待线程执行结束
主线程等待子线程完成的方法能实现代码同步吗
最新发布
08-08
<think>首先，用户的问题是关于多线程编程的：主线程等待子线程完成是否可以用于实现代码同步？这涉及到线程同步的概念。 用户提供了几个引用，我需要参考它们： - 引用[1]：使用线程管理类等待所有子线程完成，而不是用休眠方式。 - 引用[2]：使用CountDownLatch在Java中阻塞主线程直到所有子线程完成。 - 引用[3]：在Python中，使用join()方法让主线程等待子线程完成。 - 引用[4]：展示了线程池中所有线程完成后再执行主线程的后续代码。 这些引用都支持主线程等待子线程完成的做法，用于同步。 现在，用户的问题是：主线程等待子线程完成是否可以用于实现代码同步？ 答案是肯定的。代码同步通常指确保线程在特定点上协调执行，避免竞态条件。主线程等待子线程完成是一种常见的同步机制，用于确保所有子线程完成任务后，主线程才继续执行。 关键点： 1. **同步机制**：在并发编程中，同步用于控制线程执行顺序。主线程等待子线程完成是一种屏障（barrier）机制。 2. **实现方式**： - 在Java中，使用CountDownLatch或join()方法。 - 在Python中，使用thread.join()。 - 其他语言有类似机制，如C#的Task.WaitAll。 3. **优点**：简单易用，避免忙等待（如循环检查），减少CPU占用。 4. **缺点**：如果子线程阻塞或死锁，主线程可能无限期等待。需要处理异常。 5. **应用场景**：当需要聚合结果或确保所有任务完成后再进行下一步操作时。 从引用中： - [^1] 提到使用等待临界值的方式，避免休眠。 - [^2] 展示CountDownLatch示例。 - [^3] 解释Python的join()。 - [^4] 显示线程池完成后的输出。 所以，我应该基于这些构建回答。 回答结构： - 先确认答案：是的，可以用于实现代码同步。 - 解释为什么和如何实现。 - 提供示例或引用支持。 - 生成相关问题，作为输出的一部分。 系统指令要求： - 所有行内数学表达式用$...$，但这里可能不需要数学公式，除非涉及算法。 - 独立公式用$$...$$，但同样可能不适用。 - LaTeX语法正确：在需要时使用。 - 使用中文回答。 - 生成相关问题。 - 引用的段落末尾添加引用标识，如[^1]。 用户可见层要求： - 结构清晰，逐步解决问题。 - 保证真实可靠。 回答大纲： 1. **直接回答**：是的，主线程等待子线程完成可以用于实现代码同步。 2. **解释概念**：什么是代码同步？为什么需要等待子线程？ 3. **实现机制**：描述常见方法，如join(), CountDownLatch等。 4. **优点和缺点**：讨论优缺点。 5. **示例**：简要引用或描述代码示例。 6. **生成相关问题**：在最后添加相关问题。 生成相关问题： - 系统指令要求生成相关问题。 - 示例中是"§§相关问题§§"后列出问题。 - 问题应基于主题，如多线程同步的其他方法、优化等。 相关问题想法： 1. 主线程等待子线程完成有哪些常见实现方式？ 2. 如何避免主线程无限期等待子线程？ 3. 在多线程编程中，除了等待完成，还有哪些同步机制？ 4. 在Python或Java中，具体如何实现主线程等待所有子线程？ 确保回答真实可靠：基于标准多线程编程知识。</think>### 主线程等待子线程完成是否可以用于实现代码同步？ 是的，主线程等待子线程完成是一种常见的代码同步机制，在多线程编程中被广泛使用。代码同步的核心目的是协调多个线程的执行顺序，确保数据一致性和避免竞态条件（race conditions）。主线程通过等待所有子线程完成任务后再继续执行，可以有效实现这种同步，尤其在需要聚合子线程结果或确保所有任务完成后才进行后续操作的场景中。下面我将逐步解释这一机制的原理、实现方式、优缺点，并引用相关示例来支持分析。 #### 1. **为什么主线程等待子线程能实现同步？** - 在并发环境中，多个线程可能同时访问共享资源，如果不加控制，会导致数据不一致或错误。主线程等待子线程完成的机制创建了一个“屏障”（barrier），主线程在此处阻塞，直到所有子线程达到某个完成点（如执行完毕），从而保证所有子线程的任务都已处理完毕，后续代码可以安全执行。 - 这种机制避免了“忙等待”（busy-waiting），即主线程不断循环检查子线程状态（这会浪费CPU资源），而是使用高效的阻塞方式，如信号量或回调机制。 - 引用支持：在Java中，CountDownLatch类允许主线程通过`await()`方法阻塞，直到所有子线程调用`countDown()`表示完成[^2]。在Python中，`join()`方法让主线程阻塞，直到子线程终止[^3]。 #### 2. **如何实现主线程等待子线程完成？** 实现方式取决于编程语言，但核心思想类似：主线程启动子线程后，调用一个同步工具来阻塞自身，直到所有子线程发出完成信号。以下是常见语言的示例： - **Java 实现（使用 CountDownLatch）**: - CountDownLatch 是一个同步辅助类，初始化时指定子线程数量。每个子线程完成后调用`countDown()`，主线程调用`await()`阻塞等待。 - 示例代码（基于引用[2]）： ```java public static void main(String[] args) throws InterruptedException { System.out.println("主线程启动"); CountDownLatch latch = new CountDownLatch(2); // 初始化计数器为子线程数量 new Thread(() -> { System.out.println("子线程1开始"); // 模拟任务执行 try { Thread.sleep(1000); } catch (InterruptedException e) {} System.out.println("子线程1结束"); latch.countDown(); // 计数器减1 }).start(); new Thread(() -> { System.out.println("子线程2开始"); try { Thread.sleep(1500); } catch (InterruptedException e) {} System.out.println("子线程2结束"); latch.countDown(); // 计数器减1 }).start(); latch.await(); // 主线程阻塞，直到计数器归零 System.out.println("所有子线程完成，主线程继续"); } ``` - 输出可能为： ``` 主线程启动 子线程1开始 子线程2开始 子线程1结束 子线程2结束 所有子线程完成，主线程继续 ``` - 优点：高效，不消耗额外CPU资源；缺点：需要手动管理计数器，如果子线程数量动态变化，需小心设计[^2]。 - **Python 实现（使用 join()）**: - Python 的 threading 模块提供`join()`方法，主线程调用子线程的`join()`会阻塞，直到该线程结束。对于多个子线程，可以遍历并调用每个线程的`join()`。 - 示例代码（基于引用[3]）： ```python import threading import time def worker(name): print(f"{name}开始") time.sleep(1) # 模拟任务 print(f"{name}结束") if __name__ == "__main__": print("主线程启动") threads = [] for i in range(2): t = threading.Thread(target=worker, args=(f"子线程{i+1}",)) threads.append(t) t.start() for t in threads: t.join() # 主线程阻塞，等待每个子线程完成 print("所有子线程完成，主线程继续") ``` - 输出类似： ``` 主线程启动 子线程1开始 子线程2开始 子线程1结束 子线程2结束 所有子线程完成，主线程继续 ``` - 优点：简单易用；缺点：如果子线程出现死锁，主线程会无限等待，需要异常处理[^3]。 - **通用实现（线程池）**: - 对于线程池场景，如Java的ExecutorService或Python的ThreadPoolExecutor，可以使用`shutdown()` + `awaitTermination()`或`join()`来等待所有任务完成。 - 引用支持：在引用[4]中，线程池所有子线程完成后，主线程才输出“结束了！”，这通过类似机制实现[^4]。 #### 3. **优点和缺点分析** - **优点**： - **简单可靠**：易于实现，且能有效保证同步，避免主线程在子线程未完成时访问不完整数据。 - **资源高效**：相比忙等待（如循环检查子线程状态），阻塞机制减少了CPU占用，提高了性能[^1][^2]。 - **通用性强**：适用于多种场景，如并行计算、任务批处理或数据聚合。 - **缺点**： - **潜在死锁风险**：如果子线程阻塞或未正确调用完成信号（如忘记`countDown()`），主线程会无限期等待，导致程序挂起。需要添加超时机制（如Java的`await(long timeout, TimeUnit unit)`或Python的`join(timeout)`）。 - **灵活性受限**：不适合动态增减线程的场景；如果子线程数量大，管理开销可能增加。 - **异常传播问题**：子线程的异常可能不会自动传递给主线程，需额外处理（如Java的Future或Python的异常捕获）。 #### 4. **适用场景** - 这种同步机制在以下情况特别有用： - **数据聚合**：例如，多个子线程计算部分结果，主线程汇总。 - **资源初始化**：所有子线程加载配置或数据后，主线程才启动应用。 - **测试和调试**：确保并发任务完成后再验证输出。 - 引用支持：在Android开发中，主线程等待UI更新子线程完成，以避免界面卡顿[^1]。 总之，主线程等待子线程完成是一种有效的代码同步方法，但需结合超时和异常处理来增强鲁棒性。在实际应用中，根据语言和框架选择合适工具（如Java的CountDownLatch、Python的join()或C#的Barrier），可以高效实现线程协调。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值