Java异步编程Future应用

已于 2023-11-08 15:48:36 修改
阅读量2.9k 收藏 5
点赞数
分类专栏： java 文章标签： java 开发语言
于 2022-07-14 18:14:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZGL_cyy/article/details/125788219
版权

目录

在这里插入图片描述

想学习架构师构建流程请跳转：Java架构师系统架构设计

1 Future接口介绍

此时有的人会说，对于任务并行需求，直接通过多线程实现不就可以了， 要注意，对于多线程的实现，java提供了三种方式：继承Thread类、实现Runnable接口和实现Callable接口。
但是业务代码在执行时会考虑执行顺序的问题，直接基于这些方式实现多线程会出现两个问题：
1）要想控制线程执行顺序，会通过join()等待线程结束，那这样的话又回归到了阻塞式调用的思路上，违背了并行的需求。 另外还可以通过wait()、notify()、notifyAll()结合状态变量实现，但实现起来过于复杂。
2）线程执行完之后，要想获取线程执行结果，还要用过共享变量或线程间通信等方式来获取，同样过于复杂。为了解决上述问题，Java5中推出了Future，其初衷就是用于构建复杂并行操作。内部方法在返回时，不是返回一个值，而是返回Future对象。其本质是在执行主业务的同时，异步的执行其他分业务，从而利用原本需要同步执行时的等待时间去执行其他的业务，当需要获取其结果时，再进行获取。

Java官网对于Future的描述：
在这里插入图片描述
Future表示异步计算的结果。 提供了一些方法来检查计算是否完成，等待其完成以及检索计算结果。 只有在计算完成后才可以使用get方法检索结果，必要时将其阻塞，直到准备就绪为止。 取消通过cancel方法执行。 提供了其他方法来确定任务是正常完成还是被取消。 一旦计算完成，就不能取消计算。
在这里插入图片描述
在Future接口中有五个抽象方法：
在这里插入图片描述
cancel()：取消任务, 取消成功返回true；入参mayInterruptIfRunning表示是否允许取消正在执行中的任务。

在这里插入图片描述
isCancelled()：返回布尔值，代表是否取消成功。

在这里插入图片描述
isDone()：返回布尔值，代表是否执行完毕。

在这里插入图片描述
get()：返回Future对象，获取执行结果，如果任务没有完成会阻塞到任务完成再返回。

2 Future应用

Future的使用通常需要配合ExecutorService和Callable一起
使用，使用示例如下：

public class FutureAsyncDemo {
  static Random random = new Random();
  static ExecutorService executor =
Executors.newCachedThreadPool();
  //接收文章名称，获取并计算文章分数
  public static int getArticleScore(String
aname){
    Future<Integer> futureA =
executor.submit(new
CalculateArticleScoreA());
    Future<Integer> futureB =
executor.submit(new
CalculateArticleScoreA());
    Future<Integer> futureC =
executor.submit(new
CalculateArticleScoreA());
    doSomeThingElse();
    Integer a = null;
    try {
      a = futureA.get();
   } catch (InterruptedException e) {
      futureA.cancel(true);
      e.printStackTrace();
   } catch (ExecutionException e) {
      futureA.cancel(true);
       e.printStackTrace();
   }
    Integer b = null;
    try {
      b = futureB.get();
   } catch (InterruptedException e) {
      futureB.cancel(true);
      e.printStackTrace();
   } catch (ExecutionException e) {
      futureB.cancel(true);
      e.printStackTrace();
   }
    Integer c = null;
    try {
      c = futureC.get();
   } catch (InterruptedException e) {
      futureC.cancel(true);
      e.printStackTrace();
   } catch (ExecutionException e) {
      futureC.cancel(true);
      e.printStackTrace();
   }
    executor.shutdown();
    return a+b+c;
 }
  private static void doSomeThingElse() {
    System.out.println("exec other
things");
 }
  public static void main(String[] args) {
  
 System.out.println(getArticleScore("demo"))
;
 }
}
class CalculateArticleScoreA implements
Callable<Integer>{
  @Override
  public Integer call() throws Exception {
    //业务代码
    Random random = new Random();
    TimeUnit.SECONDS.sleep(3);
  
 System.out.println(Thread.currentThread().g
etName());
    return random.nextInt(100);
 }
}

执行结果

exec other things
pool-1-thread-1
pool-1-thread-3
pool-1-thread-2
159

上述方法改造了calculateArticleScore()，在其内部基于线程池调用重写了Callable接口中的call()，并在call()中对具体业
务完成编码，并且让其在执行时睡三秒钟。根据结果可以看到，先调用了计算文章分数方法，其内部开启了子线程去执行任务，并且子线程在执行时，并没有阻塞主线程的执行。当主线程需要结果时，在通过返回的Future来获取子任务中的返回值。

3 Future并行变串行问题解析

刚才已经基于Future演示了并行执行的效果，已经达到了期望，但是在使用的过程中，其实还有个坑需要说明。对于
Future的使用，如稍加不注意，就会让并行变为串行。
示例代码如下：

public class FutureAsyncDemo {
  static ExecutorService executor =
Executors.newCachedThreadPool();
  //接收文章名称，获取并计算文章分数
  public static int getArticleScore(String
aname){
    Future<Integer> futureA =
executor.submit(new
CalculateArticleScoreA());
    Future<Integer> futureB =
executor.submit(new
CalculateArticleScoreB());
     Future<Integer> futureC =
executor.submit(new
CalculateArticleScoreC());
    doSomeThingElse();
    Integer a = 0;
    try {
      a = futureA.get();
   } catch (InterruptedException e) {
      futureA.cancel(true);
      e.printStackTrace();
   } catch (ExecutionException e) {
      futureA.cancel(true);
      e.printStackTrace();
   }
    Integer b = 0;
    try {
      b = futureB.get();
   } catch (InterruptedException e) {
      futureB.cancel(true);
      e.printStackTrace();
   } catch (ExecutionException e) {
      futureB.cancel(true);
      e.printStackTrace();
   }
    Integer c = 0;
    try {
      c = futureC.get();
   } catch (InterruptedException e) {
       futureC.cancel(true);
      e.printStackTrace();
   } catch (ExecutionException e) {
      futureC.cancel(true);
      e.printStackTrace();
   }
    executor.shutdown();
    return a+b+c;
 }
  private static void doSomeThingElse() {
    System.out.println("exec other
things");
 }
  public static void main(String[] args) {
  
 System.out.println(getArticleScore("demo"))
;
 }
}
class CalculateArticleScoreA implements
Callable<Integer>{
  @Override
  public Integer call() throws Exception {
    Random random = new Random();
    TimeUnit.SECONDS.sleep(10);
   
 System.out.println(Thread.currentThread().g
etName());
    return random.nextInt(100);
 }
}
class CalculateArticleScoreB implements
Callable<Integer>{
  @Override
  public Integer call() throws Exception {
    Random random = new Random();
    TimeUnit.SECONDS.sleep(20);
  
 System.out.println(Thread.currentThread().g
etName());
    return random.nextInt(100);
 }
}
class CalculateArticleScoreC implements
Callable<Integer>{
  @Override
  public Integer call() throws Exception {
    Random random = new Random();
    TimeUnit.SECONDS.sleep(30);
  
 System.out.println(Thread.currentThread().g
etName());
    return random.nextInt(100);
 }
 }

上述代码加计算得分方法复制出来两份，各自休眠10秒、20秒、30秒。当方法返回Future之后，调用get()进行值获取时，发现每次调用时都需要进行等待。这样可以发现，之前的并行现在变成了串行了！！！！ 这个问题为什么会产生呢？需要看一下Future中对于get()的介绍
在这里插入图片描述
根据源码可知，当调用get()时，其会等待对应方法执行完毕后，才会返回结果，否则会一直等待。因为这个设定，所以上述代码则出现并行变串行的效果。
对于这个问题的解决，可以调用get()的重载，get(longtimeout, TimeUnit unit)。设置等待的时长，如果超时则抛出TimeoutException。

使用示例如下：

public class FutureAsyncDemo {
  static Random random = new Random();
  static ExecutorService executor =
Executors.newCachedThreadPool();
  //接收文章名称，获取并计算文章分数
   public static int
getArticleScore(String aname){
    Future<Integer> futureA =
executor.submit(new
CalculateArticleScoreA());
    Future<Integer> futureB =
executor.submit(new
CalculateArticleScoreB());
    Future<Integer> futureC =
executor.submit(new
CalculateArticleScoreC());
    doSomeThingElse();
    Integer a = 0;
    try {
      a = futureA.get();
   } catch (InterruptedException e) {
      futureA.cancel(true);
      e.printStackTrace();
   } catch (ExecutionException e) {
      futureA.cancel(true);
      e.printStackTrace();
   }
    Integer b = 0;
    try {
       b = futureB.get(3L,
TimeUnit.SECONDS);
   } catch (TimeoutException e) {
      e.printStackTrace();
   }
    catch (InterruptedException e) {
      futureB.cancel(true);
      e.printStackTrace();
   } catch (ExecutionException e) {
      futureB.cancel(true);
      e.printStackTrace();
   }
    Integer c = 0;
    try {
      c = futureC.get();
   } catch (InterruptedException e) {
      futureC.cancel(true);
      e.printStackTrace();
   } catch (ExecutionException e) {
      futureC.cancel(true);
      e.printStackTrace();
   }
    executor.shutdown();
    return a+b+c;
 }
  private static void doSomeThingElse() {
     System.out.println("exec other
things");
 }
  public static void main(String[] args)
{
  
 System.out.println(getArticleScore("demo")
);
 }
}
class CalculateArticleScoreA implements
Callable<Integer>{
  @Override
  public Integer call() throws Exception
{
    Random random = new Random();
    TimeUnit.SECONDS.sleep(10);
  
 System.out.println(Thread.currentThread().
getName());
    return random.nextInt(100);
 }
}
class CalculateArticleScoreB implements
Callable<Integer>{
  @Override
  public Integer call() throws Exception
{
    Random random = new Random();
    TimeUnit.SECONDS.sleep(20);
  
 System.out.println(Thread.currentThread().
getName());
    return random.nextInt(100);
 }
}
class CalculateArticleScoreC implements
Callable<Integer>{
  @Override
  public Integer call() throws Exception
{
    Random random = new Random();
    TimeUnit.SECONDS.sleep(30);
  
 System.out.println(Thread.currentThread().
getName());
    return random.nextInt(100);
 }
}

在上述方法中，对于B的get()设置了超时时间三秒钟，如果当调用其获取返回值时，如果超过三秒仍然没有返回结果，则抛出超时异常，接着方法会再次向下运行。

对于Future来说，它能够支持任务并发执行，对于任务结果的获取顺序是按照提交的顺序获取，在使用的过程中建议通过CPU高速轮询的方式获取任务结果，但这种方式比较耗费资源。不建议使用

赵广陆
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java并发-异步执行Future
算法-和为S的数字
09-14 1636
Java并发-异步执行Future 在开发过程中很容易遇到这么一种情况，要执行一个耗时的任务，为了提高效率我们在执行耗时任务的时候同时执行其他暂时不需要耗时任务的代码，直到需要这个耗时任务的返回时才去获取任务结果，那么在Java中Future接口是专门用来异步执行，并在需要的时候获取执行的结果的一个接口。典型的我们有 /** * jdk 8 * / public class Main ...
Java异步处理CompletableFuture
xizi1103的博客
02-28 989
Java异步处理CompletableFuture 异步处理简单来说就是另起一个线程处理，使程序不至于阻塞到某一步，导致后续代码无法执行。 异步处理的方法有很多，懒的话直接new Thread(() -> {}).start();，也不是不行。但是这样会让自己显得很low，不能向别人装13。再进一步，其实可以用线程池来管理，但是各种线程之间的通信也很麻烦，还要注意线程安全的问题。jdk1.8...
Java的Future使用方法
12-22
首先，Future是一个接口，该接口用来返回异步的结果。 package com.itbuluoge.mythread; import java.util.ArrayList; 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
掌握Java Future模式及其灵活应用
宋小黑的博客
01-10 1002
Future模式是Java异步编程的基础，它允许咱们将耗时的任务放在后台执行，提高了程序的性能和响应性。尽管Future有一些局限性，如阻塞问题和异常处理不够灵活，但咱们可以通过使用或结合其他异步编程技术来克服这些限制。Java中还有其他异步编程的工具和框架，如RxJava、ScheduledExecutorService等，它们在特定场景下可以提供更优的解决方案。
理解 Java 中的 Future 及其底层实现
fudaihb的博客
06-20 779
在现代并发编程中，异步编程是提高应用程序性能和响应能力的重要手段。为了有效地管理并发任务，Java 提供了多种工具和框架，其中 `Future` 是一个关键组件。本文将深入探讨 Java 中的 `Future`，包括其基本概念、用法、优缺点及底层实现原理。
java Future 接口使用方法详解
08-31
主要介绍了java Future 接口使用方法详解，Future接口是Java线程Future模式的实现，可以来进行异步计算的相关资料,需要的朋友可以参考下
【并发编程】Java的Future机制详解（Future接口和FutureTask类）
小七的博客
06-30 9764
Java的Future机制详解
JAVA Future类详解
热门推荐
bobozai86的博客
04-05 3万+
1. Future的应用场景 在并发编程中，我们经常用到非阻塞的模型，在之前的多线程的三种实现中，不管是继承thread类还是实现runnable接口，都无法保证获取到之前的执行结果。通过实现Callback接口，并用Future可以来接收多线程的执行结果。 Future表示一个可能还没有完成的异步任务的结果，针对这个结果可以添加Callback以便在任务执行成功或失败后作出相应的操作。 举个例子：比如去吃早点时，点了包子和凉菜，包子需要等3分钟，凉菜只需1分钟，如果...
Java中的Future
tugangkai的专栏
12-27 8264
1.Future解决了什么问题 Future是java中的一个接口，主要用于java多线程计算过程的异步结果获取，能够感知计算的进度，与传统的多线程实现方式，比如继承Thread类，实现runnable接口，它们主要的局限在于对多线程运行的本身缺少监督。 2.Callable接口和Runnable接口区别 下面是它们之间的主要区别: runable接口是用run方法作为线程运行任务的入口，cal...
Java的Future机制详解
u013950690的博客
03-31 2873
B图表达的是使用Future模式之后，我们主线程在invoke之后可以立即返回，去做其他的事情，回头再来看看刚才提交的invoke有没有结果。而如果使用第二个构造函数那么最后获取线程实行结果就是参数中的result，接下来让我们看一下FutureTask的run方法。方法能准确地告诉你某个字段相对于对象的起始内存地址的字节偏移量，因为是相对偏移量，所以它其实跟某个具体对象又没什么太大关系，跟class的定义和虚拟机的内存模型的实现细节更相关。get方法有两个，一个是有超时时间设置，另一个没有超时时间设置。
【第十二篇】Java 线程池Future和FutureTask【重点】
sunnyday0426的博客
03-01 1万+
1.1 概述   本文主要讲解Java线程池与Future和FutureTask的结合使用，通过本文的学习你可以轻松的在日常开发中运用线程池与Future和FutureTask的使用。 Future的出现原因 我们在Java线程池ThreadPoolExecutor详解中利用execute(Runnable r)方法来异步执行任务，但是有一个缺点，就是无法执行带有返回值的任务。 1.2 原理详解 1.2.1 结构图 FutureTask实现了RunnableFuture接口，而RunnableFutu
java异步编程详解
08-26
java异步编程详解 Java异步编程是Java编程语言中的一种编程模型，它允许程序异步地执行任务，以提高程序的性能和响应速度。在Java中，异步编程可以通过多种方式实现，包括使用Future、Callable、Runnable、Thread、...
Java 异步编程实践_动力节点Java学院整理
08-30
在Java中实现异步编程需要使用Future和FutureTask，它们位于java.util.concurrent包下。Future是一个接口而FutureTask是它的一个实现类。使用Future可以实现异步任务的执行，并且调用线程可以得到结果promise。 ...
CompletableFuture：Java异步编程利器.pptx.pptx
12-21
CompletableFuture 是 Java 8 引入的重要特性，它扩展了 Future 接口，为开发者提供了强大的异步编程能力。CompletableFuture 不仅是非阻塞的，意味着在等待结果的同时，程序可以继续执行其他任务，提高了程序的并发...
异步编程的瑞士军刀：Java中Future和Callable接口的妙用
最新发布
07-21
Java是一种广泛使用的编程语言，由Sun Microsystems公司（现属于Oracle公司）在1995年首次发布。...5. **网络编程**：Java提供了丰富的网络通信API，使得开发网络应用变得容易。 6. **安全性**：Java提供了一个安全
Java多线程之异步Future机制的原理和实现共5页.p
10-30
本文将深入探讨Java多线程中的异步Future机制，包括其原理、实现方式以及实际应用。 首先，我们需要了解什么是Future。在Java中，`java.util.concurrent.Future`接口代表一个异步计算的结果。它提供了检查计算是否...
Java并发编程学习九：Future
weixin_41402069的博客
08-02 2364
Java并发编程学习系列
【并发编程】Java5 - Future，基本使用
C3Stones
03-28 1603
1. 简介   在使用多线程开发中，不论是继承Thread类还是实现Runnable接口方式，都无法非常方便的获取异步任务执行的结果。在JDK1.5提供了和Runnable类似但多了返回值的Callable接口，通过Future接口实现类和Callable接口方式，可以非常灵活的进行多线程操作，例如：获取结果、指定超时时间获取结果、取消任务、判断是否取消、判断是否完成等。 2. Future接口...
java的异步编程是什么意思
05-12
Java的异步编程是一种编程模型，它可以在执行某些长时间运行的操作时，不会阻塞主线程，而是在后台线程中执行这些操作。这种编程模型可以提高程序的性能和响应性，因为它允许应用程序在执行其他任务时继续进行。在Java中，异步编程通常使用回调函数、Future和CompletableFuture等技术实现。其中，回调函数是一种将函数作为参数传递给另一个函数的方法，用于在异步操作完成时通知应用程序。Future和CompletableFuture则是一种更高级的异步编程技术，它们可以使异步代码更加优雅和易于管理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

赵广陆

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值