第31篇：等待线程完成的方式你知道几种？

star2017 1年前 ⋅ 598 阅读

java高并发系列已经学了不少东西了，本篇文章，我们用前面学的知识来实现一个需求：

在一个线程中需要获取其他线程的执行结果，能想到几种方式？各有什么优缺点？

结合这个需求，我们使用6种方式，来对之前学过的知识点做一个回顾，加深记忆。

方式1：Thread的join()方法实现

代码：

  1. package com.itsoku.chat31;
  3. import java.sql.Time;
  4. import java.util.concurrent.*;
  6. /**
  7.  * 跟着阿里p7学并发，微信公众号：javacode2018
  8.  */
  9. public class Demo1 {
  10.     //用于封装结果
  11.     static class Result<T> {
  12.         T result;
  14.         public T getResult() {
  15.             return result;
  16.         }
  18.         public void setResult(T result) {
  19.             this.result = result;
  20.         }
  21.     }
  23.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  24.         System.out.println(System.currentTimeMillis());
  25.         //用于存放子线程执行的结果
  26.         Result<Integer> result = new Result<>();
  27.         //创建一个子线程
  28.         Thread thread = new Thread(() -> {
  29.             try {
  30.                 TimeUnit.SECONDS.sleep(3);
  31.                 result.setResult(10);
  32.             } catch (InterruptedException e) {
  33.                 e.printStackTrace();
  34.             }
  35.         });
  36.         thread.start();
  37.         //让主线程等待thread线程执行完毕之后再继续，join方法会让当前线程阻塞
  38.         thread.join();
  40.         //获取thread线程的执行结果
  41.         Integer rs = result.getResult();
  42.         System.out.println(System.currentTimeMillis());
  43.         System.out.println(System.currentTimeMillis() + ":" + rs);
  44.     }
  45. }

输出：

  1. 1566733162636
  2. 1566733165692
  3. 1566733165692:10

代码中通过join方式阻塞了当前主线程，当thread线程执行完毕之后，join方法才会继续执行。

关于join()方法和线程更详细的使用，可以参考：线程的基本操作

方式2：CountDownLatch实现

代码：

  1. package com.itsoku.chat31;
  3. import java.util.concurrent.*;
  5. /**
  6.  * 跟着阿里p7学并发，微信公众号：javacode2018
  7.  */
  8. public class Demo2 {
  9.     //用于封装结果
  10.     static class Result<T> {
  11.         T result;
  13.         public T getResult() {
  14.             return result;
  15.         }
  17.         public void setResult(T result) {
  18.             this.result = result;
  19.         }
  20.     }
  22.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  23.         System.out.println(System.currentTimeMillis());
  24.         CountDownLatch countDownLatch = new CountDownLatch(1);
  25.         //用于存放子线程执行的结果
  26.         Demo1.Result<Integer> result = new Demo1.Result<>();
  27.         //创建一个子线程
  28.         Thread thread = new Thread(() -> {
  29.             try {
  30.                 TimeUnit.SECONDS.sleep(3);
  31.                 result.setResult(10);
  32.             } catch (InterruptedException e) {
  33.                 e.printStackTrace();
  34.             }finally {
  35.                 countDownLatch.countDown();
  36.             }
  37.         });
  38.         thread.start();
  39.         //countDownLatch.await()会让当前线程阻塞，当countDownLatch中的计数器变为0的时候，await方法会返回
  40.         countDownLatch.await();
  42.         //获取thread线程的执行结果
  43.         Integer rs = result.getResult();
  44.         System.out.println(System.currentTimeMillis());
  45.         System.out.println(System.currentTimeMillis() + ":" + rs);
  46.     }
  47. }

输出：

  1. 1566733720406
  2. 1566733723453
  3. 1566733723453:10

上面代码也达到了预期效果，使用CountDownLatch可以让一个或者多个线程等待一批线程完成之后，自己再继续；CountDownLatch更详细的介绍见：JUC中等待多线程完成的工具类CountDownLatch，必备技能

方式3：ExecutorService.submit方法实现

代码：

  1. package com.itsoku.chat31;
  3. import java.util.concurrent.*;
  5. /**
  6.  * 跟着阿里p7学并发，微信公众号：javacode2018
  7.  */
  8. public class Demo3 {
  9.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  10.         //创建一个线程池
  11.         ExecutorService executorService = Executors.newCachedThreadPool();
  12.         System.out.println(System.currentTimeMillis());
  13.         Future<Integer> future = executorService.submit(() -> {
  14.             try {
  15.                 TimeUnit.SECONDS.sleep(3);
  16.             } catch (InterruptedException e) {
  17.                 e.printStackTrace();
  18.             }
  19.             return 10;
  20.         });
  21.         //关闭线程池
  22.         executorService.shutdown();
  23.         System.out.println(System.currentTimeMillis());
  24.         Integer result = future.get();
  25.         System.out.println(System.currentTimeMillis() + ":" + result);
  26.     }
  27. }

输出：

  1. 1566734119938
  2. 1566734119989
  3. 1566734122989:10

使用ExecutorService.submit方法实现的，此方法返回一个Future，future.get()会让当前线程阻塞，直到Future关联的任务执行完毕。

相关知识：

  1. JAVA线程池，这一篇就够了
  2. JUC中的Executor框架详解1
  3. JUC中的Executor框架详解2

方式4：FutureTask方式1

代码：

  1. package com.itsoku.chat31;
  3. import java.util.concurrent.*;
  5. /**
  6.  * 跟着阿里p7学并发，微信公众号：javacode2018
  7.  */
  8. public class Demo4 {
  9.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  10.         System.out.println(System.currentTimeMillis());
  11.         //创建一个FutureTask
  12.         FutureTask<Integer> futureTask = new FutureTask<>(() -> {
  13.             try {
  14.                 TimeUnit.SECONDS.sleep(3);
  15.             } catch (InterruptedException e) {
  16.                 e.printStackTrace();
  17.             }
  18.             return 10;
  19.         });
  20.         //将futureTask传递一个线程运行
  21.         new Thread(futureTask).start();
  22.         System.out.println(System.currentTimeMillis());
  23.         //futureTask.get()会阻塞当前线程，直到futureTask执行完毕
  24.         Integer result = futureTask.get();
  25.         System.out.println(System.currentTimeMillis() + ":" + result);
  26.     }
  27. }

输出：

  1. 1566736350314
  2. 1566736350358
  3. 1566736353360:10

代码中使用FutureTask实现的，FutureTask实现了Runnable接口，并且内部带返回值，所以可以传递给Thread直接运行，futureTask.get()会阻塞当前线程，直到FutureTask构造方法传递的任务执行完毕，get方法才会返回。关于FutureTask详细使用，请参考：

方式5：FutureTask方式2

代码：

  1. package com.itsoku.chat31;
  3. import java.util.concurrent.ExecutionException;
  4. import java.util.concurrent.FutureTask;
  5. import java.util.concurrent.TimeUnit;
  7. /**
  8.  * 跟着阿里p7学并发，微信公众号：javacode2018
  9.  */
  10. public class Demo5 {
  11.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  12.         System.out.println(System.currentTimeMillis());
  13.         //创建一个FutureTask
  14.         FutureTask<Integer> futureTask = new FutureTask<>(() -> 10);
  15.         //将futureTask传递一个线程运行
  16.         new Thread(() -> {
  17.             try {
  18.                 TimeUnit.SECONDS.sleep(3);
  19.             } catch (InterruptedException e) {
  20.                 e.printStackTrace();
  21.             }
  22.             futureTask.run();
  23.         }).start();
  24.         System.out.println(System.currentTimeMillis());
  25.         //futureTask.get()会阻塞当前线程，直到futureTask执行完毕
  26.         Integer result = futureTask.get();
  27.         System.out.println(System.currentTimeMillis() + ":" + result);
  28.     }
  29. }

输出：

  1. 1566736319925
  2. 1566736319970
  3. 1566736322972:10

创建了一个FutureTask对象，调用futureTask.get()会阻塞当前线程，子线程中休眠了3秒，然后调用futureTask.run();当futureTask的run()方法执行完毕之后，futureTask.get()会从阻塞中返回。

注意：这种方式和方式4的不同点。

关于FutureTask详细使用，请参考：JUC中的Executor框架详解1

方式6：CompletableFuture方式实现

代码：

  1. package com.itsoku.chat31;
  3. import java.util.concurrent.CompletableFuture;
  4. import java.util.concurrent.ExecutionException;
  5. import java.util.concurrent.FutureTask;
  6. import java.util.concurrent.TimeUnit;
  8. /**
  9.  * 跟着阿里p7学并发，微信公众号：javacode2018
  10.  */
  11. public class Demo6 {
  12.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  13.         System.out.println(System.currentTimeMillis());
  14.         CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
  15.             try {
  16.                 TimeUnit.SECONDS.sleep(3);
  17.             } catch (InterruptedException e) {
  18.                 e.printStackTrace();
  19.             }
  20.             return 10;
  21.         });
  22.         System.out.println(System.currentTimeMillis());
  23.         //futureTask.get()会阻塞当前线程，直到futureTask执行完毕
  24.         Integer result = completableFuture.get();
  25.         System.out.println(System.currentTimeMillis() + ":" + result);
  26.     }
  27. }

输出：

  1. 1566736205348
  2. 1566736205428
  3. 1566736208429:10

CompletableFuture.supplyAsync可以用来异步执行一个带返回值的任务，调用completableFuture.get()

会阻塞当前线程，直到任务执行完毕，get方法才会返回。

关于CompletableFuture更详细的使用见：JUC中工具类CompletableFuture，必备技能

最新资料

更多内容请访问：IT源点

注意：本文归作者所有，未经作者允许，不得转载

#Java高并发教程
阅读全部
相关文章推荐
  • 1
  • 2

全部评论: 0 条

    我有话说: