java中Future使用详细介绍

已于 2024-05-29 15:22:46 修改
阅读量406 收藏 1
点赞数 7
文章标签： java 开发语言
于 2024-05-28 18:03:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43950588/article/details/139269000
版权

一、什么是Future？

在并发编程中，可以通过Future对象来异步获取结果。
使用Thread或runnable接口都不能获取异步的执行结果，因为他们没有返回值。而通过实现Callable接口和Future就可以获取异步执行的结果，当异步执行结束后，返回结果将保存在Future中。使用Future就可以让我们暂时去处理其他的任务而无需一直等待结果，等异步任务执行完毕再返回其结果。

二、Future中的get方法

1、get方法
获取任务结束后返回的结果，如果调用时，任务还没有结束，则会进行阻塞线程，直到任务完成。该阻塞是可以被打断的，打断的线程是调用get方法的线程，被打断后原任务会依旧继续执行。

V get() throws InterruptedException, ExecutionException;

2、指定时间的get方法
获取任务结束后返回的结果，如果调用时，任务还没有结束，则会进行阻塞线程，等待一定时间，如果在规定时间内任务结束则返回结果，否则抛出TimeoutException，超时后任务依旧会继续执行。该阻塞是可以被打断的，打断的线程是调用get方法的线程，被打断后原任务会依旧继续执行。

V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;

三、Future代码示例

步骤1：创建一个线程池

public class AsyncTaskExecutor {
    /**
     * 核心线程数
     */
    private static final int corePoolSize = 10;

    /**
     * 最大线程数
     */
    private static final int maxPoolSize = 30;

    /**
     * 空闲线程回收时间
     * 空闲线程是指：当前线程池中超过了核心线程数之后，多余的空闲线程的数量
     */
    private static final int keepAliveTime = 100;

    /**
     * 任务队列/阻塞队列
     */
    private static final int blockingQueueSize = 99999;

    private static final ThreadPoolExecutor executorPool = new ThreadPoolExecutor(
            corePoolSize,
            maxPoolSize,
            keepAliveTime,
            TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<>(blockingQueueSize),
            new ThreadFactoryBuilder().setNameFormat("AsyncTaskThread" + "-%d").build(),
            new ThreadPoolExecutor.CallerRunsPolicy()
    );

    /**
     * 异步任务执行
     *
     * @param task
     */
    public static void execute(Runnable task) {
        executorPool.execute(task);
    }

    /**
     * 异步执行任务Callable, 通过Future获取结果
     *
     * @param task
     * @param <T>
     * @return
     */
    public static <T> Future<T> submit(Callable<T> task) {
        return executorPool.submit(task);
    }

    /**
     * 异步执行任务Runnable，通过Future获取结果
     *
     * @param task
     * @return
     */
    public static Future<?> submit(Runnable task) {
        return executorPool.submit(task);
    }

}

步骤2：编写测试类

    @Test
    public void test2() {
        try {
            Future<String> future = AsyncTaskExecutor.submit(() -> {
                log.info("[Future Task] future task start...");
                try {
                    //模拟任务执行
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    log.info(e.getMessage());
                }
                log.info("[Future Task] future task end...");
                return "Task completed...";
            });

            //执行其他任务
            log.info("[Main Thread] main thread is running...");

            //使用future阻塞等待任务完成，并获取结果
            String futureResult = future.get();
            log.info("[Main Thread] {}", futureResult);

        }catch (Exception e) {
            e.printStackTrace();
        }
    }

步骤3：查看结果

2024-05-28 10:58:23.633  INFO 1184 --- [           main] com.example.demo.dao.UserDaoTest         : [Main Thread] main thread is running...
2024-05-28 10:58:23.633  INFO 1184 --- [yncTaskThread-0] com.example.demo.dao.UserDaoTest         : [Future Task] future task start...
2024-05-28 10:58:28.633  INFO 1184 --- [yncTaskThread-0] com.example.demo.dao.UserDaoTest         : [Future Task] future task end...
2024-05-28 10:58:28.634  INFO 1184 --- [           main] com.example.demo.dao.UserDaoTest         : [Main Thread] Task completed...

四、ListenableFuture

public class AsyncTaskExecutor {
    /**
     * 核心线程数
     */
    private static final int corePoolSize = 10;

    /**
     * 最大线程数
     */
    private static final int maxPoolSize = 30;

    /**
     * 空闲线程回收时间
     * 空闲线程是指：当前线程池中超过了核心线程数之后，多余的空闲线程的数量
     */
    private static final int keepAliveTime = 100;

    /**
     * 任务队列/阻塞队列
     */
    private static final int blockingQueueSize = 99999;

    private static final ThreadPoolExecutor executorPool = new ThreadPoolExecutor(
            corePoolSize,
            maxPoolSize,
            keepAliveTime,
            TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<>(blockingQueueSize),
            new ThreadFactoryBuilder().setNameFormat("AsyncTaskThread" + "-%d").build(),
            new ThreadPoolExecutor.CallerRunsPolicy()
    );

    /**
     * 创建一个ListeningExecutorService，用于执行异步任务
     * （通过submit提交任务，以ListenableFuture获取结果）
     */
    private static final ListeningExecutorService LISTENING_EXECUTOR = MoreExecutors.listeningDecorator(executorPool);

    /**
     * 异步任务执行
     *
     * @param task
     */
    public static void execute(Runnable task) {
        executorPool.execute(task);
    }

    /**
     * 异步执行任务Callable, 通过ListenableFuture获取结果
     *
     * @param task
     * @param <T>
     * @return
     */
    public static <T> ListenableFuture<T> submit(Callable<T> task) {
        return LISTENING_EXECUTOR.submit(task);
    }

    /**
     * 异步执行任务Runnable，通过Future获取结果
     *
     * @param task
     * @return
     */
    public static ListenableFuture<?> submit(Runnable task) {
        return LISTENING_EXECUTOR.submit(task);
    }
}


	//示例1：
    @Test
    public void test2() {
       ListenableFuture<School> listenableFuture1 = AsyncTaskExecutor.submit(() -> {
                try {
                    //模拟任务执行
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    log.info(e.getMessage());
                }
                return new School("DSchool");
            });
            ListenableFuture<School> listenableFuture2 = AsyncTaskExecutor.submit(() -> {
                try {
                    //模拟任务执行
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    log.info(e.getMessage());
                }
                return new School("ESchool");
            });

            //阻塞等待，直到listenableFuture1 和 listenableFuture2都获取到结果后或其中一个异常
            Futures.successfulAsList(listenableFuture1, listenableFuture2).get();
            School resSchool1 = listenableFuture1.get();
            School resSchool2 = listenableFuture2.get();
            log.info("[Main Thread] result1 is {}", JSON.toJSONString(resSchool1));
            log.info("[Main Thread] result2 is {}", JSON.toJSONString(resSchool2));

            //任意位置即时设定ListenableFuture的返回结果
            ListenableFuture<School> listenableFuture3 = Futures.immediateFuture(new School("aaa"));
            ListenableFuture<School> listenableFuture4 = Futures.immediateFailedFuture(new Exception("eeee"));
            log.info("[Main Thread] listenableFuture3 is {}", listenableFuture3.get());
            log.info("[Main Thread] listenableFuture4 is {}", listenableFuture4.get());
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
    
	//示例2：
    public static void main(String[] args) {
        // 创建一个ListeningExecutorService，用于执行异步任务
        ListeningExecutorService executor = MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor());

        // 提交一个异步任务，并得到ListenableFuture对象
        ListenableFuture<String> listenableFuture = executor.submit(() -> {
            // 模拟耗时操作
            Thread.sleep(2000);
            return "Result of the asynchronous computation";
        });

        // 注册异步操作完成时的回调函数
        Futures.addCallback(listenableFuture, new FutureCallback<String>() {
            @Override
            public void onSuccess(String result) {
                System.out.println("Result: " + result);
                executor.shutdown(); // 关闭executor
            }

            @Override
            public void onFailure(Throwable t) {
                t.printStackTrace();
                executor.shutdown(); // 关闭executor
            }
        }, executor);
    }

五、CompletableFuture

	//示例1：
	public static void main(String[] args) {
        // 创建一个CompletableFuture对象
        CompletableFuture<School> completableFuture = new CompletableFuture<>();

        // 异步任务：模拟一个耗时操作
        new Thread(() -> {
            try {
                // 模拟耗时操作
                Thread.sleep(2000);
                // 完成CompletableFuture并设置值
                completableFuture.complete(new School("completableSchool"));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        // 在这里等待异步任务的结果并输出
        try {
            School result = completableFuture.get();
            log.info("[CompletableFuture] result is {}" ,result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }

	//示例2：
    @Test
    public void test2() {
        try {
            //创建一个CompletableFuture对象
            CompletableFuture<School> schoolFuture = new CompletableFuture<>();
            //任意位置即时设定CompletableFuture的返回结果
            schoolFuture.complete(new School("FSchool"));
            School school = schoolFuture.get();
            log.info("[Main Thread] result is {}", JSON.toJSONString(school));
            
        }catch (Exception e) {
            log.info(e.getMessage());
        }
    }

六、SettableFuture

	//示例1：
	public static void main(String[] args) {
        // 创建一个SettableFuture对象
        SettableFuture<String> settableFuture = SettableFuture.create();

        // 手动设置异步操作的结果
        settableFuture.set("Result of the asynchronous computation");

        // 注册异步操作完成时的回调函数
        settableFuture.addListener(() -> {
            try {
                String result = settableFuture.get(); // 获取异步操作的结果
                System.out.println("Result: " + result);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, Runnable::run);
    }
    
	//示例2：
	@Test
    public void test2() {
        try {
            //创建一个SettableFuture对象
            SettableFuture<School> settableFuture = SettableFuture.create();
            //任意位置即时设定SettableFuture的返回结果
            settableFuture.set(new School("GSchool"));
            School setSchool = settableFuture.get();
            log.info("[Main Thread] setSchool is {}", JSON.toJSONString(setSchool));
            
        }catch (Exception e) {
            log.info(e.getMessage());
        }
    }
时间_wys
关注
  • 7
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
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 FutureTask类使用案例解析
08-19
主要介绍了Java FutureTask类使用案例解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值析,需要的朋友可以参考下
newsinglethreadexecutor使用场景_java中Future的使用
weixin_39569747的博客
11-29 449
Future是java 1.5引入的一个interface，可以方便的用于异步结果的获取。 本文将会通过具体的例子讲解如何使用Future。创建Future正如上面所说，Future代表的是异步执行的结果，意思是当异步执行结束之后，返回的结果将会保存在Future中。那么我们什么时候会用到Future呢？ 一般来说，当我们执行一个长时间运行的任务时，使用Future就可以让我们暂时去处理其他的任务...
Java线程池详解：Future的使用和实现
最新发布
bjmsb79的博客
07-07 2117
java复制代码public class FutureTask implements RunnableFuture { // 为Callable任务生成FutureTask public FutureTask(Callable callable) { if (callable == null) throw new NullPointerException();
java中Future的使用
yzx3105的博客
10-24 1137
submit需要接受一个Callable参数，Callable需要实现一个call方法，并返回结果。如果在等待时间结束的时候，Future还有返回，则会抛出一个TimeoutException。一般来说，当我们执行一个长时间运行的任务时，使用Future就可以让我们暂时去处理其他的任务，等长任务执行完毕再返回其结果。Future代表的是异步执行的结果，意思是当异步执行结束之后，返回的结果将会保存在Future中。这里futureOne.get()是一个阻塞操作，会一直等待异步执行完毕才返回结果。
java Future模式的使用
zangjunlang4288的博客
10-08 166
java Future模式的使用 一、Future模式的使用。 Future模式简述 传统单线程环境下，调用函数是同步的，必须等待程序返回结果后，才可进行其他处理。 Futrue模式下，调用方式改为异步。 Futrue模式的核心在于：充分利用主函数中的等待时间，利用等待时间处理其他任务，充分利用计算机资源。 主要角色 Main：系...
java Future的使用
yzj479622672的博客
08-23 2143
java中future的使用
Java中Future模式的使用
weixin_42809053的博客
10-24 2383
文章目录前言能不能再快点落地一下**按照顺序的思想执行**按照异步的思想执行异步的思想今天的猪脚，jdk中的Future模式总结 前言 今天是1024，祝各位老板节日快乐！ 傍晚打算下楼买点吃的，心中打定了注意，今晚要买【鸡蛋仔】和【手抓饼】，好家伙，这不素材就有了嘛，嘿嘿嘿！ 于是我便迈着“六亲不认”的步伐出发了… 能不能再快点 ❓路上，我思考了一个问题。那就是我到底需要耗费多长时间，才能握住简单的快乐？ 按照流程是这样子的 骑着我心爱的小摩托出发 到达买鸡蛋仔的摊位，点一份鸡蛋仔，然后等老板做完
Java Future详解与使用
数据工匠记
04-13 2634
原文地址：https://dayarch.top/p/java-future-and-callable.html 前言 创建线程有几种方式？这个问题的答案应该是可以脱口而出的吧 继承 Thread 类 实现 Runnable 接口 但这两种方式创建的线程是属于”三无产品“： 没有参数 没有返回值 没办法抛出异常 class MyThread implements Runnable{ @Override public void run() { log.info("my t.
老生常谈java中的Future模式
08-30
在 Java 中，Future 模式可以使用 ExecutorService 和 Callable 实现。下面是一个简单的示例代码： ```java ExecutorService executor = Executors.newSingleThreadExecutor(); Future<String> future = executor....
比较java中Future与FutureTask之间的关系
08-26
本文将详细介绍Future和FutureTask的关系、使用和分析。 一、Future介绍 Future位于java.util.concurrent包下，是一个接口，定义了五个方法： 1. `cancel(boolean mayInterruptIfRunning)`: 取消任务，取消成功则...
java Future 接口使用方法详解
08-31
下面我们将详细探讨`Future`接口的使用方法。 1. **接口方法解析** - `boolean cancel(boolean mayInterruptIfRunning)`：用于取消任务的执行。如果`mayInterruptIfRunning`为`true`，则尝试中断正在执行的任务；...
Java使用Callable和Future创建线程操作示例
08-25
Java使用Callable和Future创建线程操作示例主要介绍了Java使用Callable和Future创建线程操作，结合实例形式分析了java使用Callable接口和Future类创建线程的相关操作技巧与注意事项。 首先，Java 5开始，Java提供了...
【并发编程】Java5 - Future，基本使用
C3Stones
03-28 1594
1. 简介   在使用多线程开发中，不论是继承Thread类还是实现Runnable接口方式，都无法非常方便的获取异步任务执行的结果。在JDK1.5提供了和Runnable类似但多了返回值的Callable接口，通过Future接口实现类和Callable接口方式，可以非常灵活的进行多线程操作，例如：获取结果、指定超时时间获取结果、取消任务、判断是否取消、判断是否完成等。 2. Future接口...
【Java多线程】Future类使用
Sun_study的博客
04-01 1353
Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果等操作。它代表是异步执行的结果，意思是当异步执行结束之后，返回的结果将会保存在Future中。当我们提交一个Callable任务后，我们会同时获得一个Future对象，然后，我们在主线程某个时刻调用Future对象的get()方法，就可以获得异步执行的结果。在调用get()时，如果异步任务已经完成，我们就直接获得结果。如果异步任务还没有完成，那么get()会阻塞，直到任务完成后才返回结果。
Java使用Future_java Future 接口使用方法详解
weixin_35715474的博客
03-08 289
java Future 接口使用方法详解在Java中，如果需要设定代码执行的最长时间，即超时，可以用Java线程池ExecutorService类配合FFuture接口是一个泛型接口，严格的格式应该是Future，其中V代表了Future执行的任务返回值的类型。 Future接口www.cppcns.com的方法介绍如下：boolean cancel (boolean mayInterruptIf...
Java异步编程Future应用
赵广陆
07-14 2817
目录 1 Future接口介绍 2 Future应用 3 Future并行变串行问题解析 1 Future接口介绍 此时有的人会说，对于任务并行需求，直接通过多线程实现不就可以了， 要注意，对于多线程的实现，java提供了三种方式：继承Thread类、实现Runnable接口和实现Callable接口。......
java Future使用例子
03-04
可以这样使用 Future： 1. 定义一个 Callable 对象，实现 call() 方法，返回需要异步执行的结果。 2. 创建一个 ExecutorService 对象，调用 submit() 方法提交 Callable 对象，返回一个 Future 对象。 3. 调用 Future 对象的 get() 方法，获取异步执行的结果。 示例代码如下： ``` import java.util.concurrent.*; public class FutureExample { public static void main(String[] args) throws Exception { // 定义一个 Callable 对象 Callable<Integer> task = new Callable<Integer>() { public Integer call() throws Exception { // 模拟耗时操作 Thread.sleep(100); return 100; } }; // 创建一个 ExecutorService 对象 ExecutorService executor = Executors.newSingleThreadExecutor(); // 提交 Callable 对象，返回一个 Future 对象 Future<Integer> future = executor.submit(task); // 获取异步执行的结果 Integer result = future.get(); System.out.println("异步执行的结果是：" + result); // 关闭 ExecutorService 对象 executor.shutdown(); } } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值