Java高并发专题之34、谷歌提供的一些好用的并发工具类

关于并发方面的，juc已帮我们提供了很多好用的工具，而谷歌在此基础上做了扩展，使并发编程更容易，这些工具放在guava.jar包中。

本文演示几个简单的案例，见一下guava的效果。

guava maven配置

  1. <dependency>
  2.     <groupId>com.google.guava</groupId>
  3.     <artifactId>guava</artifactId>
  4.     <version>27.0-jre</version>
  5. </dependency>

guava中常用几个类

MoreExecutors：提供了一些静态方法，是对juc中的Executors类的一个扩展。
Futures：也提供了很多静态方法，是对juc中Future的一个扩展。

案例1：异步执行任务完毕之后回调

  1. package com.itsoku.chat34;
  3. import com.google.common.util.concurrent.ListenableFuture;
  4. import com.google.common.util.concurrent.ListeningExecutorService;
  5. import com.google.common.util.concurrent.MoreExecutors;
  6. import lombok.extern.slf4j.Slf4j;
  8. import java.util.concurrent.ExecutionException;
  9. import java.util.concurrent.ExecutorService;
  10. import java.util.concurrent.Executors;
  11. import java.util.concurrent.TimeUnit;
  13. /**
  14.  * 跟着阿里p7学并发，微信公众号：javacode2018
  15.  */
  16. @Slf4j
  17. public class Demo1 {
  18.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  19.         //创建一个线程池
  20.         ExecutorService delegate = Executors.newFixedThreadPool(5);
  21.         try {
  22.             ListeningExecutorService executorService = MoreExecutors.listeningDecorator(delegate);
  23.             //异步执行一个任务
  24.             ListenableFuture<Integer> submit = executorService.submit(() -> {
  25.                 log.info("{}", System.currentTimeMillis());
  26.                 //休眠2秒，默认耗时
  27.                 TimeUnit.SECONDS.sleep(2);
  28.                 log.info("{}", System.currentTimeMillis());
  29.                 return 10;
  30.             });
  31.             //当任务执行完毕之后回调对应的方法
  32.             submit.addListener(() -> {
  33.                 log.info("任务执行完毕了，我被回调了");
  34.             }, MoreExecutors.directExecutor());
  35.             log.info("{}", submit.get());
  36.         } finally {
  37.             delegate.shutdown();
  38.         }
  39.     }
  40. }

输出：

  1. 14:25:50.055 [pool-1-thread-1] INFO com.itsoku.chat34.Demo1 - 1567491950047
  2. 14:25:52.063 [pool-1-thread-1] INFO com.itsoku.chat34.Demo1 - 1567491952063
  3. 14:25:52.064 [pool-1-thread-1] INFO com.itsoku.chat34.Demo1 - 任务执行完毕了，我被回调了
  4. 14:25:52.064 [main] INFO com.itsoku.chat34.Demo1 - 10

说明：

ListeningExecutorService接口继承于juc中的ExecutorService接口，对ExecutorService做了一些扩展，看其名字中带有Listening，说明这个接口自带监听的功能，可以监听异步执行任务的结果。通过MoreExecutors.listeningDecorator创建一个ListeningExecutorService对象，需传递一个ExecutorService参数，传递的ExecutorService负责异步执行任务。

ListeningExecutorService的submit方法用来异步执行一个任务，返回ListenableFuture，ListenableFuture接口继承于juc中的Future接口，对Future做了扩展，使其带有监听的功能。调用submit.addListener可以在执行的任务上添加监听器，当任务执行完毕之后会回调这个监听器中的方法。

ListenableFuture的get方法会阻塞当前线程直到任务执行完毕。

上面的还有一种写法，如下：

  1. package com.itsoku.chat34;
  3. import com.google.common.util.concurrent.*;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.checkerframework.checker.nullness.qual.Nullable;
  7. import java.util.concurrent.ExecutionException;
  8. import java.util.concurrent.ExecutorService;
  9. import java.util.concurrent.Executors;
  10. import java.util.concurrent.TimeUnit;
  12. /**
  13.  * 跟着阿里p7学并发，微信公众号：javacode2018
  14.  */
  15. @Slf4j
  16. public class Demo2 {
  17.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  18.         ExecutorService delegate = Executors.newFixedThreadPool(5);
  19.         try {
  20.             ListeningExecutorService executorService = MoreExecutors.listeningDecorator(delegate);
  21.             ListenableFuture<Integer> submit = executorService.submit(() -> {
  22.                 log.info("{}", System.currentTimeMillis());
  23.                 TimeUnit.SECONDS.sleep(4);
  24.                 //int i = 10 / 0;
  25.                 log.info("{}", System.currentTimeMillis());
  26.                 return 10;
  27.             });
  28.             Futures.addCallback(submit, new FutureCallback<Integer>() {
  29.                 @Override
  30.                 public void onSuccess(@Nullable Integer result) {
  31.                     log.info("执行成功:{}", result);
  32.                 }
  34.                 @Override
  35.                 public void onFailure(Throwable t) {
  36.                     try {
  37.                         TimeUnit.MILLISECONDS.sleep(100);
  38.                     } catch (InterruptedException e) {
  39.                         e.printStackTrace();
  40.                     }
  41.                     log.error("执行任务发生异常:" + t.getMessage(), t);
  42.                 }
  43.             }, MoreExecutors.directExecutor());
  44.             log.info("{}", submit.get());
  45.         } finally {
  46.             delegate.shutdown();
  47.         }
  48.     }
  49. }

输出：

  1. 14:26:07.938 [pool-1-thread-1] INFO com.itsoku.chat34.Demo2 - 1567491967936
  2. 14:26:11.944 [pool-1-thread-1] INFO com.itsoku.chat34.Demo2 - 1567491971944
  3. 14:26:11.945 [main] INFO com.itsoku.chat34.Demo2 - 10
  4. 14:26:11.945 [pool-1-thread-1] INFO com.itsoku.chat34.Demo2 - 执行成功:10

上面通过调用Futures的静态方法addCallback在异步执行的任务中添加回调，回调的对象是一个FutureCallback，此对象有2个方法，任务执行成功调用onSuccess，执行失败调用onFailure。

失败的情况可以将代码中int i = 10 / 0;注释去掉，执行一下可以看看效果。

示例2：获取一批异步任务的执行结果

  1. package com.itsoku.chat34;
  3. import com.google.common.util.concurrent.Futures;
  4. import com.google.common.util.concurrent.ListenableFuture;
  5. import com.google.common.util.concurrent.ListeningExecutorService;
  6. import com.google.common.util.concurrent.MoreExecutors;
  7. import lombok.extern.slf4j.Slf4j;
  9. import java.util.ArrayList;
  10. import java.util.List;
  11. import java.util.concurrent.*;
  12. import java.util.stream.Collectors;
  14. /**
  15.  * 跟着阿里p7学并发，微信公众号：javacode2018
  16.  */
  17. @Slf4j
  18. public class Demo3 {
  19.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  20.         log.info("star");
  21.         ExecutorService delegate = Executors.newFixedThreadPool(5);
  22.         try {
  23.             ListeningExecutorService executorService = MoreExecutors.listeningDecorator(delegate);
  24.             List<ListenableFuture<Integer>> futureList = new ArrayList<>();
  25.             for (int i = 5; i >= 0; i--) {
  26.                 int j = i;
  27.                 futureList.add(executorService.submit(() -> {
  28.                     TimeUnit.SECONDS.sleep(j);
  29.                     return j;
  30.                 }));
  31.             }
  32.             //获取一批任务的执行结果
  33.             List<Integer> resultList = Futures.allAsList(futureList).get();
  34.             //输出
  35.             resultList.forEach(item -> {
  36.                 log.info("{}", item);
  37.             });
  38.         } finally {
  39.             delegate.shutdown();
  40.         }
  41.     }
  42. }

输出：

  1. 14:26:35.970 [main] INFO com.itsoku.chat34.Demo3 - star
  2. 14:26:41.137 [main] INFO com.itsoku.chat34.Demo3 - 5
  3. 14:26:41.138 [main] INFO com.itsoku.chat34.Demo3 - 4
  4. 14:26:41.138 [main] INFO com.itsoku.chat34.Demo3 - 3
  5. 14:26:41.138 [main] INFO com.itsoku.chat34.Demo3 - 2
  6. 14:26:41.138 [main] INFO com.itsoku.chat34.Demo3 - 1
  7. 14:26:41.138 [main] INFO com.itsoku.chat34.Demo3 - 0

结果中按顺序输出了6个异步任务的结果，此处用到了Futures.allAsList方法，看一下此方法的声明：

  1. public static <V> ListenableFuture<List<V>> allAsList(
  2.       Iterable<? extends ListenableFuture<? extends V>> futures)

传递一批ListenableFuture，返回一个ListenableFuture<List<V>>，内部将一批结果转换为了一个ListenableFuture对象。

示例3：一批任务异步执行完毕之后回调

异步执行一批任务，最后技术其和

  1. package com.itsoku.chat34;
  3. import com.google.common.util.concurrent.*;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.checkerframework.checker.nullness.qual.Nullable;
  7. import java.util.ArrayList;
  8. import java.util.List;
  9. import java.util.concurrent.ExecutionException;
  10. import java.util.concurrent.ExecutorService;
  11. import java.util.concurrent.Executors;
  12. import java.util.concurrent.TimeUnit;
  14. /**
  15.  * 跟着阿里p7学并发，微信公众号：javacode2018
  16.  */
  17. @Slf4j
  18. public class Demo4 {
  19.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  20.         log.info("star");
  21.         ExecutorService delegate = Executors.newFixedThreadPool(5);
  22.         try {
  23.             ListeningExecutorService executorService = MoreExecutors.listeningDecorator(delegate);
  24.             List<ListenableFuture<Integer>> futureList = new ArrayList<>();
  25.             for (int i = 5; i >= 0; i--) {
  26.                 int j = i;
  27.                 futureList.add(executorService.submit(() -> {
  28.                     TimeUnit.SECONDS.sleep(j);
  29.                     return j;
  30.                 }));
  31.             }
  32.             ListenableFuture<List<Integer>> listListenableFuture = Futures.allAsList(futureList);
  33.             Futures.addCallback(listListenableFuture, new FutureCallback<List<Integer>>() {
  34.                 @Override
  35.                 public void onSuccess(@Nullable List<Integer> result) {
  36.                     log.info("result中所有结果之和：" + result.stream().reduce(Integer::sum).get());
  37.                 }
  39.                 @Override
  40.                 public void onFailure(Throwable t) {
  41.                     log.error("执行任务发生异常:" + t.getMessage(), t);
  42.                 }
  43.             }, MoreExecutors.directExecutor());
  44.         } finally {
  45.             delegate.shutdown();
  46.         }
  47.     }
  48. }

输出：

  1. 14:47:04.819 [main] INFO com.itsoku.chat34.Demo4 - star
  2. 14:47:09.933 [pool-1-thread-1] INFO com.itsoku.chat34.Demo4 - result中所有结果之和：15

代码中异步执行了一批任务，所有任务完成之后，回调了上面的onSuccess方法，内部对所有的结果进行sum操作。

总结

  • 通过guava提供的一些工具类，方便异步执行任务并进行回调

  • guava内部还有很多好用的工具类，有兴趣的可以去研究一下

来源：http://itsoku.com/course/1/34

posted @ 2022-05-04 23:38  程序员小明1024  阅读(81)  评论(0)  编辑  收藏  举报