Java高并发专题之31、等待线程完成的方式你知道几种?

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

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

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

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

代码:

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

输出:

  1. 1566733162636
  2. 1566733165692
  3. 1566733165692:10

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

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

方式2:CountDownLatch实现

代码:

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

输出:

  1. 1566733720406
  2. 1566733723453
  3. 1566733723453:10

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

方式3:ExecutorService.submit方法实现

代码:

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

输出:

  1. 1566734119938
  2. 1566734119989
  3. 1566734122989:10

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

相关知识:

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

方式4:FutureTask方式1

代码:

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

输出:

  1. 1566736350314
  2. 1566736350358
  3. 1566736353360:10

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

方式5:FutureTask方式2

代码:

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

输出:

  1. 1566736205348
  2. 1566736205428
  3. 1566736208429:10

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

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

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

来源:http://itsoku.com/course/1/31
posted @ 2022-05-04 23:27  程序员小明1024  阅读(96)  评论(0编辑  收藏  举报