主线程等待子线程执行完成的三种方法介绍

最新推荐文章于 2022-06-22 10:48:02 发布
最新推荐文章于 2022-06-22 10:48:02 发布
阅读量3.3k 收藏 9
点赞数 2
文章标签： 主线程等待子线程结束 join CountDownLatch Future Callable
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fanfan_v5/article/details/63683626
版权

举个场景，用户表t_user根据userid做了分库分表，数据散列在了三个库表里t_user1、t_user2、t_user3，此时的count(t_user)需要count(t_user1) + count(t_user2) + count(t_user3)。我们为了提高性能，减少count(t_user)的响应时长，可以通过多线程并行执行各个子count，然后在主线程里将各个子任务的结果集进行合并。
如何让主线程等待子线程执行完成，本文介绍三种方式，并分析利弊。


1.thread.join()


thread.join()的作用是让当前线程（调用该方法所在的线程）阻塞住直到该thread线程终止。

1.不使用线程池 
package com.fanfan.concurrent.threadjoin;

/**
 * Created by fanfan on 2017/3/19.
 */
public class UserServiceWithNoThreadPool {

    public int count() throws Exception {
        int[] counts = {0, 0, 0};
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                counts[0] = count1();
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                counts[1] = count2();
            }
        });
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                counts[2] = count3();
            }
        });
        t1.start();
        t2.start();
        t3.start();

        t1.join();
        t2.join();
        t3.join();

        return counts[0] + counts[1] + counts[2];
    }

    private int count1() {
        try {Thread.sleep(3000L);} catch (InterruptedException e) {e.printStackTrace();}
        return 10;
    }

    private int count2() {
        try {Thread.sleep(3000L);} catch (InterruptedException e) {e.printStackTrace();}
        return 100;
    }

    private int count3() {
        try {Thread.sleep(3000L);} catch (InterruptedException e) {e.printStackTrace();}
        return 1000;
    }

    public static void main(String[] args) throws Exception {
        UserServiceWithNoThreadPool userService = new UserServiceWithNoThreadPool();
        System.out.println(userService.count());
    }
}
2.使用线程池

在使用线程池的时候，我们就不能直接操作线程对象了，也就拿不到线程的句柄。另外，线程池里的线程处理完任务之后不是立即终止而是阻塞等待其它任务的执行，而thread.join()是要求线程终止，所以本质上thread.join()不适合应用在使用线程池的情况。


2.CountDownLatch


调用thread.join()方法必须等thread执行完毕，当前线程才能继续往下执行，虽然能够达到我们的目的，但是，还不是特别灵活。比如，在使用线程池的情况下，就无法使用。
JDK1.5开始提供了CountDownLatch这个类，通过计数器提供了更加灵活的控制，只要检测到计数器为0，当前线程就可以往下执行而不用管相应的thread是否执行完毕。
CountDownLatch的原理是这样的：比如，我们创建一个计数器为3的实例，让各个线程任务持有这个CountDownLatch实例，当每个任务完成自己的工作后，调用countDownLatch.countDown()方法将计数器减1。countDownLatch.await()方法会一直阻塞直到计数器为0，主线程才会继续往下执行。

1.不使用线程池 
package com.fanfan.concurrent.countdownlatch;

import java.util.concurrent.CountDownLatch;

/**
 * Created by fanfan on 2017/3/19.
 */
public class UserServiceWithNoThreadPool {

    public int count() throws Exception {

        final CountDownLatch latch = new CountDownLatch(3);

        int[] counts = {0, 0, 0};
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                counts[0] = count1();
                latch.countDown();
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                counts[1] = count2();
                latch.countDown();
            }
        });
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                counts[2] = count3();
                latch.countDown();
            }
        });
        t1.start();
        t2.start();
        t3.start();
        latch.await();
        return counts[0] + counts[1] + counts[2];
    }

    private int count1() {
        try {Thread.sleep(3000L);} catch (InterruptedException e) {e.printStackTrace();}
        return 10;
    }

    private int count2() {
        try {Thread.sleep(3000L);} catch (InterruptedException e) {e.printStackTrace();}
        return 100;
    }

    private int count3() {
        try {Thread.sleep(3000L);} catch (InterruptedException e) {e.printStackTrace();}
        return 1000;
    }

    public static void main(String[] args) throws Exception {
        UserServiceWithNoThreadPool userService = new UserServiceWithNoThreadPool();
        System.out.println(userService.count());
    }
}
2.使用线程池 

package com.fanfan.concurrent.countdownlatch;

import java.util.concurrent.*;

/**
 * Created by fanfan on 2017/3/19.
 */
public class UserServiceWithThreadPool {

    private ExecutorService executorService;

    public int count() throws Exception {

        final CountDownLatch latch = new CountDownLatch(3);

        int[] counts = {0, 0, 0};
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                counts[0] = count1();
                latch.countDown();
            }
        });
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                counts[1] = count2();
                latch.countDown();
            }
        });
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                counts[2] = count3();
                latch.countDown();
            }
        });
        latch.await();
        return counts[0] + counts[1] + counts[2];
    }

    private int count1() {
        try {Thread.sleep(3000L);} catch (InterruptedException e) {e.printStackTrace();}
        return 10;
    }

    private int count2() {
        try {Thread.sleep(3000L);} catch (InterruptedException e) {e.printStackTrace();}
        return 100;
    }

    private int count3() {
        try {Thread.sleep(3000L);} catch (InterruptedException e) {e.printStackTrace();}
        return 1000;
    }

    public ExecutorService getExecutorService() {
        return executorService;
    }

    public void setExecutorService(ExecutorService executorService) {
        this.executorService = executorService;
    }

    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        com.fanfan.concurrent.callable.UserServiceWithThreadPool userService = new com.fanfan.concurrent.callable.UserServiceWithThreadPool();
        userService.setExecutorService(executorService);
        System.out.println(userService.count());
        executorService.shutdown();
    }
}


3.Feture、FetureTask和Callable


上面两种方法都有一个缺陷：在任务执行完毕之后无法获取执行结果，如果需要获取执行结果，就必须通过共享变量或者使用线程通信的方式来达到效果，使用起来比较麻烦。
而自JDK1.5开始，就提供了Future和Callable，通过它们可以在任务执行完毕之后得到任务执行结果。

1.不使用线程池 
package com.fanfan.concurrent.callable;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

/**
 * Created by fanfan on 2017/3/19.
 */
public class UserServiceWithNoThreadPool {

    public int count() throws Exception {
        FutureTask<Integer> futureTask1 = new FutureTask<Integer>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                return count1();
            }
        });
        FutureTask<Integer> futureTask2 = new FutureTask<Integer>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                return count2();
            }
        });
        FutureTask<Integer> futureTask3 = new FutureTask<Integer>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                return count3();
            }
        });
        new Thread(futureTask1).start();
        new Thread(futureTask2).start();
        new Thread(futureTask3).start();
        return futureTask1.get() + futureTask2.get() + futureTask3.get();
    }

    private int count1() {
        try {Thread.sleep(3000L);} catch (InterruptedException e) {e.printStackTrace();}
        return 10;
    }

    private int count2() {
        try {Thread.sleep(3000L);} catch (InterruptedException e) {e.printStackTrace();}
        return 100;
    }

    private int count3() {
        try {Thread.sleep(3000L);} catch (InterruptedException e) {e.printStackTrace();}
        return 1000;
    }

    public static void main(String[] args) throws Exception {
        UserServiceWithNoThreadPool userService = new UserServiceWithNoThreadPool();
        System.out.println(userService.count());
    }
}
2.使用线程池 
package com.fanfan.concurrent.callable;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * Created by fanfan on 2017/3/19.
 */
public class UserServiceWithThreadPool {

    private ExecutorService executorService;

    public int count() throws Exception {
        Future<Integer> future1 = executorService.submit(new Callable<Integer>() {

            @Override
            public Integer call() throws Exception {
                return count1();
            }
        });
        Future<Integer> future2 = executorService.submit(new Callable<Integer>() {

            @Override
            public Integer call() throws Exception {
                return count2();
            }
        });
        Future<Integer> future3 = executorService.submit(new Callable<Integer>() {

            @Override
            public Integer call() throws Exception {
                return count3();
            }
        });
        return future1.get() + future2.get() + future3.get();
    }

    private int count1() {
        try {Thread.sleep(3000L);} catch (InterruptedException e) {e.printStackTrace();}
        return 10;
    }

    private int count2() {
        try {Thread.sleep(3000L);} catch (InterruptedException e) {e.printStackTrace();}
        return 100;
    }

    private int count3() {
        try {Thread.sleep(3000L);} catch (InterruptedException e) {e.printStackTrace();}
        return 1000;
    }

    public ExecutorService getExecutorService() {
        return executorService;
    }

    public void setExecutorService(ExecutorService executorService) {
        this.executorService = executorService;
    }

    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        UserServiceWithThreadPool userService = new UserServiceWithThreadPool();
        userService.setExecutorService(executorService);
        System.out.println(userService.count());
        executorService.shutdown();
    }
}


总结

  1. 多线程的场景里，我们尽可能的使用线程池，而不要直接new Thread()。因为直接new Thread()除了创建线程耗时之外，更严重的问题是会造成线程数量不可控，成百上千的线程甚至更高，很容易占满内存，占满CPU。
  2. thread.join必须等待子线程执行完毕，主线程才能继续，灵活性不足，不能在线程池场景里面使用。
  3. CountDownLatch是JDK1.5开始提供的，弥补了thread.join的不足，使用起来更加灵活。可以适应于一些更加灵活的场合，比如不要求线程任务全部执行完毕，而只是在线程任务执行到某个阶段，主线程就停止阻塞继续向下执行。
  4. 为了方便获取子线程的执行结果，JDK1.5开始，提供了Future和Callable。如果遇到此类场景，优先使用Future和Callable。

秋名车手
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++主线程等待子线程结束_主线程等待子线程结束的多种方法
weixin_39629129的博客
12-21 2820
程的运行时间”。while循环对于“主线程如何获取子线程总运行时间”的问题，最开始想到的是使用while循环进行轮询：Thread t = new Thread(() -> {//子线程进行字符串连接操作int num = 1000;String s = "";for (int i = 0; i < num; i++) {s += "Java";}System.out.println(...
主线程等待子多线程(无结果返回)执行完成再继续执行
banyoyo的博客
06-09 440
当第一个主线程里的子多线程还没结束时,下一个主线程就进来了,导致在对比时可能出现线程安全问题(第二条主线程在获取本地数据时,会遗漏掉第一条主线程中多线程还没完成的数据,对比时就把遗漏数据当成新数据,再一次添加进去)接到一个同步别家数据到自己的数据库需求,首先获取到一个集合数据,与自己数据进行对比,算出新增的数据.为了最大减少延迟,这个同步时间间隔就几秒钟,处理需要花费一点时间,就会出现并发情况.:一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
java CountDownLatch用法 主线程等待子线程执行完后再执行
IT云清
07-23 4942
这里记录一下下面这种情况：主线程需要等待多个子线程执行完后再执行。 1.使用CountDownLatch 示例如下，我们初始化一个CountDownLatch，值为10（子线程个数），然后每次一个子线程执行完后执行一下countDown()，代码示例如下：...
如何让主线程等待子线程执行完毕后再执行
qq_42251944的博客
06-22 2519
总结三个方法：（1）join方法，直接将每个线程都join进去即可。（2）ountdownlatch，内部维持一个计数操作，通过cas算法保证操作的原子性，当线程执行完之后，调用countDown()方法，将计数减一，主线程调用countdownlatch对象的await()方法，将当前线程挂起，直到countdownlatch对象的计数为0，主线程执行。（3）类似屏障的东西，当子线程执行完之后，调用CyclicBarrier对象的await()方法，直到指定数量的线程到达屏障之后，才会继续执行主线程。把每
java线程池主线程等待子线程执行完成
u014203449的博客
08-19 6647
转载：https://blog.csdn.net/yaowj2/article/details/7431440 Java如何等待子线程执行结束 今天讨论一个入门级的话题, 不然没东西更新对不起空间和域名~~ 工作总往往会遇到异步去执行某段逻辑, 然后先处理其他事情, 处理完后再把那段逻辑的处理结果进行汇总的产景, 这时候就需要使用线程了. 一个线程启动之后, 是异步的去执行需要执行的内容的...
多线程-主线程等待子线程都执行结束再执行
weixin_43979189的博客
06-30 1958
多线程-主线程等待子线程都执行结束再执行 有三种方式可以实现： 使用Thread的join()等待所有的子线程执行完毕，主线程在执行； 等待多线程完成的CountDownLatch； 同步屏障CyclicBarrier； 一、使用Thread的join() ​ 使用Thread的join()等待所有的子线程执行完毕，主线程在执行，thread.join()把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继
主线程等待子线程执行完毕再执行方法
我的博客
04-27 4966
public static v...
在Java线程池中 主线程等待子线程完成任务 并返回
telltao的博客
07-08 1867
Java创建一个固定长度的线程池执行业务逻辑完成 创建一个固定长度的线程池 /** * <pre> * Create By Liu Tao * 创建一个线程池，该线程池重用在共享无界队列上运行的固定数量的线程。 * 在任何时候，大多数Threads线程都是活动的处理任务。 * 如果在所有线程都处于活动状态时提交其他任务，它们将在...
【Java并发编程】主线程等待子线程的多种方法
pcdd's blog
04-25 4168
思路：所有任务提交后，调用线程池的shutdown()方法，然后在死循环里每隔几秒调用一次线程池的isTerminated()方法，判断所有线程在线程池关闭后是否都已完成。翻译为中文：如果所有任务在关闭后都已完成，则返回 true。1 部分案例使用线程池创建线程。方便起见使用Executors.newFixedThreadPool()方法创建一个固定大小的线程池。3 代码在main()方法中执行，出于方便演示，代码中有几处不规范的地方。缺点：若线程池中的任务完成耗时不确定，则不能及时执行主线程的任务。
Python多线程:主线程等待所有子线程结束代码
09-17
4. 对每个线程调用`join()`方法，使主线程等待子线程完成。 通过这种方式，你可以确保所有子任务在主线程结束前得以完成，这对于同步和资源清理等场景非常有用。同时，理解守护线程的概念和行为对于编写健壮的多...
JAVA主线程等待子线程执行完毕再执行[参照].pdf
10-11
JAVA 主线程等待子线程执行完毕再执行 JAVA 中的线程控制是非常重要的一部分，而在实际开发中，我们经常会遇到需要主线程等待子线程执行完毕再执行的情况。这种情况下，我们可以使用两种方式来实现：主动式和被动式...
Java多线程–让主线程等待所有子线程执行完毕
12-22
要解决“让主线程等待所有子线程执行完毕”的问题，可以采用以下策略： 1. 使用`join()`方法：如提到的，直接在每个子线程的`start()`之后调用`t.join()`，会导致所有线程按顺序执行。这是因为`join()`会让主线程...
Java简单实现“主线程等待所有子线程完成再继续”
03-25
总的来说，Java提供了丰富的多线程同步机制，可以根据实际需求选择合适的方法来实现“主线程等待所有子线程完成再继续”的功能。在并发编程中，理解并灵活运用这些工具对于提高程序效率和避免死锁等问题至关重要。
Java多线程--等待所有子线程执行完的五种方法.docx
09-14
`Thread.join()`方法允许主线程等待特定线程结束。例如，如果有多个子线程，我们可以在每个子线程执行`join()`，这样主线程会依次等待每个子线程完成。例如： ```java Thread thread1 = new Thread(...); Thread ...
pillow_heif-0.17.0-pp39-pypy39_pp73-macosx_14_0_arm64.whl
07-27
基本介绍 名称与起源：Pillow，原名为PIL（Python Imaging Library），但PIL只支持Python 2版本。随着Python 3的普及，Pillow作为PIL的一个分支出现，兼容Python 3并提供更多的功能和改进。 主要功能：Pillow支持多种图像格式的打开、保存、显示以及基本的图像操作和处理，如裁剪、缩放、旋转、翻转、滤镜应用等。 跨平台性：Pillow库可以在不同的操作系统上运行，包括Windows、Linux和MacOS等。 主要功能模块 Pillow库包含多个功能模块，每个模块都提供了特定的图像处理功能。以下是一些常用的模块： Image：用于处理图像文件，提供打开、保存、调整大小、旋转、裁剪、滤镜等功能。 ImageDraw：提供在图像上绘制各种形状（如线条、矩形、圆形）和文本的功能。 ImageFont：用于加载和使用TrueType字体文件，以便在图像上绘制文本时设置字体样式、大小和颜色。 ImageFilter：提供各种滤镜效果，如模糊、锐化、边缘增强等，用于图像增强、特效处理和图像识别等应用。 ImageEnhance：用于调整图像的亮度、对比度、颜色饱和度等参数，使图像更加清晰、明亮或具有特定的调色效果。 高级功能 除了基本的图像处理功能外，Pillow还支持一些高级功能，如色彩空间转换、直方图均衡化等。这些功能可以帮助用户进行更复杂的图像处理和分析。
cykooz.resizer-3.0.0-cp310-cp310-macosx_11_0_arm64.whl
07-27
python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！
[毕设]Delphi题库管理与试卷自动生成系统.zip
最新发布
07-27
[毕设]Delphi题库管理与试卷自动生成系统
131 种水果、蔬菜和坚果的 90380张的高质量图像数据集+图像识别与定位+该数据集相关的研究论文
07-27
<项目介绍> 包含131 种水果、蔬菜和坚果的 90380张的高质量图像数据集+该数据集相关的研究论文。可供深度学习图像识别与定位。 - 训练集大小：67700 个图像 测试集大小：22888 个图像 文件名格式：image_index_100.jpg（例如 32_100.jpg）或 r_image_index_100.jpg（例如 r_32_100.jpg）或 r2_image_index_100.jpg 或 r3_image_index_100.jpg。 “r”代表旋转水果。 “r2”表示水果绕第三轴旋转。 “100”来自图像尺寸（100x100 像素）。 水果是如何拍摄的: 1:使用 C920 摄像机拍摄水果。最好的网络摄像头之一。 2:在水果后面，我们放了一张白纸作为背景。 3:将水果和蔬菜种植在低速电机（3转/分钟）的轴中，并录制一段20秒的短片。 下载后请首先打开README.md文件（如有），仅供学习参考, 切勿用于商业用途。 --------
主线程等待子线程结束继续执行
07-14
在Python中，主线程可以通过调用子线程的`join()`方法来待子线程执行完成后继续执行。`join()`方法会阻塞主线程，直到子线程执行完成。 以下是一个简单的示例代码： ```python import threading def child_thread...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值