主线程等待子线程返回结果

最新推荐文章于 2024-07-08 16:22:44 发布

花葬-天空之城

最新推荐文章于 2024-07-08 16:22:44 发布

阅读量1.3k

点赞数

分类专栏：多线程文章标签： java

原文链接：https://www.cnblogs.com/haly/p/10732332.html

版权

多线程专栏收录该内容

2 篇文章 0 订阅

订阅专栏

方案一：使用thread.join()实现

java中的join方法可以控制线程的执行顺序，这个方案主要是考察线程的join方法原理，以及thread的实现方式。

join() method suspends the execution of the calling thread until the object called finishes its execution.
大概的意思是：如果在主线程mian()中调用子线程的join()方法，就会阻塞主线程，直到子线程执行完，在唤起主线程继续执行。

至于为什么会阻塞主线程，有兴趣的同学可以继续找资料学习，这里就不多扩展了。

  package day01;
  
  public class JoinTest {
      public static void main(String[] args) {
          CalculateThread addTread = new CalculateThread(2, 3, "add");
          CalculateThread mutlTread = new CalculateThread(2, 3, "mutl");
          addTread.start(); // 子线程处理两个数相加
          mutlTread.start(); // 子线程处理两个数相乘
          try {
             addTread.join(); // 暂停主线程，让addTread先执行完
             mutlTread.join(); // 暂停主线程，让mutlTread子线程先执行完
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
 
         int threadResult = addTread.getResult() + mutlTread.getResult();
         System.out.println("主线程获得两个子线程结果的和:" + threadResult);
     }
 
 }
 
 class CalculateThread extends Thread {
     private int param1;
     private int param2;
     private String type;
     private int result; //用来保存线程执行结果
 
     public CalculateThread(int param1, int param2, String type) {
         this.param1 = param1;
         this.param2 = param2;
         this.type = type;
     }
 
     // 为了获取每个子线程计算结果
     public int getResult() {
         return result;
     }
 
     // 两个数相加
     public void add() {
         System.out.println(this.getName() + ":子线程处理两个参数相加开始");
         try {
             Thread.sleep(2000L); // 模拟加法子线程需要执行2s
 
             result = param1 + param2;
 
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println(this.getName() + ":子线程处理两个参数相加结束");
     }
 
     // 两个数相乘
     public void mult() {
         System.out.println(this.getName() + ":子线程处理两个参数相乘开始");
         try {
             Thread.sleep(1000L); // 模拟乘法子线程需要执行1s
 
             result = param1 * param2;
 
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println(this.getName() + ":子线程处理两个参数相乘结束");
     }
 
     @Override
     public void run() {
         // TODO Auto-generated method stub
         switch (type) {
         case "add": // switch的string类型，jdk 1.7才开始支持
             add();
             break;
         case "mutl":
             mult();
             break;
         default:
             break;
         }
     }
}

方案一注意：

join()一定要在start()方法之后调用。所以如果多个子线程执行，要先循环执行完子线程的start()方法，再循环执行join()方法，这样才能变成并行执行。

如果执行一个子线程的start()方法后，就直接执行这个子线程的join()方法，由于主线程阻塞主了，所以需要等这个线程执行完，后面的线程才能执行，就变成串行的了。
每个子线程计算的返回值，我们目前是用子线程里的变量保存实现的，我们也可以用主线程的引用类型当作共享变量实现（这个要考虑并发下，线程安全问题）。

方案二：使用Future和Callable实现

Future是可以保存返回值的，这也是很多人知道的方案，Future封装了多个方法，可以很好的获取线程执行状态，以及异常处理，这里我们就不扩展了，有兴趣的同学可以自己再去学习。

 package day01;
 
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 
 public class FutureTest {
     public static void main(String[] args) {
         try {
             CalculateCallable addCalable = new CalculateCallable(2, 3, "add");
             CalculateCallable mutlCalable = new CalculateCallable(2, 3, "mutl");
             // new 两个线程,固定线程
             ExecutorService execute = Executors.newFixedThreadPool(2);
             // 返回 Futrue对象后，可以使用 Futrue.get() 方法获取返回值
             Future<Integer> addFuture = execute.submit(addCalable);
             Future<Integer> mutlFuture = execute.submit(mutlCalable);
 
             int futurResult = addFuture.get() + mutlFuture.get();
             System.out.println("主线程获得两个子线程结果的和:" + futurResult);
 
         } catch (ExecutionException e) {
             e.printStackTrace();
         } catch (InterruptedException e1) {
             e1.printStackTrace();
         }
     }
 }
 
 class CalculateCallable implements Callable<Integer> {
     private int param1;
     private int param2;
     private String type;
 
     public CalculateCallable(int param1, int param2, String type) {
         this.param1 = param1;
         this.param2 = param2;
         this.type = type;
     }
 
     // 两个数相加
     public int add() {
         System.out.println("加法子线程处理两个参数相加开始");
         try {
             Thread.sleep(2000L); // 模拟加法子线程需要执行2s
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("加法子线程处理两个参数相加结束");
 
         return param1 + param2;
     }
 
     // 两个数相乘
     public int mult() {
         System.out.println("乘法子线程处理两个参数相乘开始");
         try {
             Thread.sleep(1000L); // 模拟乘法子线程需要执行1s
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("乘法子线程处理两个参数相乘结束");
         return param1 * param2;
 
     }
 
     @Override
     public Integer call() throws Exception {
         // TODO Auto-generated method stub
         switch (type) {
         case "add": // switch的string类型，jdk 1.7才开始支持
             return add();
         case "mutl":
             return mult();
         default:
             return null;
         }
     }
 
 }

方案二注意：

Future接口调用get()方法取得处理的结果值时是阻塞性的，如果调用Future对象的get()方法时，任务尚未执行完成，则调用get()方法时一直阻塞到此任务完成为止。

如果这样，则前面先执行的任务一旦耗时很多，后面的任务调用get()方法就呈阻塞状态，也就是排队进行等待。主线程并不能保证首先获得结果的是最先完成任务线程的返回值，大大影响运行效率。那么使用多线程就没什么意义了。

幸运的是JDK并发包也提供了CompletionService接口可以解决这个问题，它的take()方法哪个线程先完成就先获取谁的Futrue对象，有兴趣的可以去仔细了解下相关知识点。

方案三：使用CountDownLatch实现

这个方案，当时面试的时候没想到，但是是一个很好很强大的并发类。

CountDownLatch存在于java.util.concurrent包下。CountDownLatch这个类能够使一个线程等待其他线程完成各自的工作后再执行。例如，应用程序的主线程希望负责启动框架服务的线程在已经启动所有的框架服务之后再执行。

CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。

 package day01;
 
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 
 public class CountDownLatchTest {
     public static void main(String[] args) {
         // 初始值为2，因为我们目前就2个子线程
         CountDownLatch countDownLatch = new CountDownLatch(2);  
         // 每个线程中传入countDownLatch
         CountDownThread addTread = new CountDownThread(2,3,"add",countDownLatch);
         CountDownThread mutlTread = new CountDownThread(2,3,"mutl",countDownLatch);
         addTread.start();
         mutlTread.start();
         try{
             // 设置超时时间为3秒,3s如果线程没有执行完，返回false
             boolean timeoutFlag = countDownLatch.await(3,TimeUnit.SECONDS);  
             if(timeoutFlag){  
                 int threadResult = addTread.getResult() + mutlTread.getResult();
                 System.out.println("主线程获得两个子线程结果的和:" + threadResult);
             }else{
                 int threadResult = addTread.getResult() + mutlTread.getResult();
                 System.out.println("主线程等待子线程执行超时:" + threadResult);
             }
             
         }catch (InterruptedException e){
             e.printStackTrace();  
         }  
     }
 }
     
 
 class CountDownThread extends Thread{
     private int param1;
     private int param2;
     private String type;
     private int result;
     private CountDownLatch countDownLatch;
 
     public CountDownThread(int param1,int param2,String type,CountDownLatchuntDownLatch){
         this.param1 = param1;
         this.param2 = param2;
         this.type = type;
         this.countDownLatch = countDownLatch;
     }
     
     // 为了获取每个子线程计算结果
     public int getResult() {
         return result;
     }
 
     // 两个数相加
     public void add(){
         System.out.println(this.getName()+":子线程处理两个参数相加开始");
         try{
             Thread.sleep(2000L); //模拟加法子线程需要执行2s
             
             result = param1 + param2;
             
             System.out.println(this.getName()+":子线程处理两个参数相加结束");
             
         }catch(InterruptedException e){
             e.printStackTrace();
         }finally{
             // 计数器减1  
             countDownLatch.countDown();  
         }
     }
     
     // 两个数相乘
     public void mult(){
         System.out.println(this.getName()+":子线程处理两个参数相乘开始");
         try{
             Thread.sleep(1000L); //模拟乘法子线程需要执行1s
             
             result = param1 * param2;
             
             System.out.println(this.getName()+":子线程处理两个参数相乘结束");
 
         }catch(InterruptedException e){
             e.printStackTrace();
         }finally{
             // 计数器减1  
            countDownLatch.countDown();  
         }
     }
     
     @Override
     public void run() {
         // TODO Auto-generated method stub
         switch (type) {
          case "add": //switch的string类型，jdk 1.7才开始支持
              add();
              break;
          case "mutl":
             mult();
             break;
         default:
             break;
         }
     }
 }

如果我们将超时时间改成1s ，boolean timeoutFlag = countDownLatch.await(1,TimeUnit.SECONDS); 由于计算相加时睡眠了2s，相乘时睡眠了1s

所以，相加的计算是直接超时的,timeoutFlag会返回false，最终计算结果是2 * 3 = 6。

方案三注意:

CountDownLatch的缺点是CountDownLatch是一次性的，计数器的值只能在构造方法中初始化一次，之后没有任何机制再次对其设置值，当CountDownLatch使用完毕后，它不能再次被使用。

2.countDownLatch.countDown() 最好在finally块中执行，防止子线程没有执行完，就自减1了，导致主线程没有等到所有子线程执行完，便执行了。

其实我们在工作中遇到的业务场景往往比较复杂，对并发，异常的处理都比较严格，这里只是给大家提供一个方向，以后遇到类似的功能需求，我们不会像无头苍蝇一样，至少有了解决问题的方向。

花葬-天空之城

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
主线程等待子线程返回结果

方案一：使用thread.join()实现java中的join方法可以控制线程的执行顺序，这个方案主要是考察线程的join方法原理，以及thread的实现方式。join() method suspends the execution of the calling thread until the object called finishes its execution.大概的意思是：如果在主线程mian()中调用子线程的join()方法，就会阻塞主线程，直到子线程执行完，在唤起主线程继续执行。至于
复制链接

扫一扫

专栏目录