Future & Futures

最新推荐文章于 2025-06-20 18:12:04 发布

原创最新推荐文章于 2025-06-20 18:12:04 发布 · 823 阅读

1 ·

CC 4.0 BY-SA版权

java 同时被 2 个专栏收录

152 篇文章

订阅专栏

一周一篇Java概念

144 篇文章

订阅专栏

本文探讨了Java并发编程中Future模式的应用，解释了为何需要Future及其实现原理，并对比了Future与AIO的不同之处。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

java.util.concurrent.Future

为什么需要Future？

java调用其他程序的并行编程有同步异步、阻塞非阻塞之分。其中同步阻塞实践意义有但不广泛，异步和非阻塞能让主线程继续执行比较适合广泛使用。而且在并行编程的时候需要关注的点还在于：调用结果如何返回、是否能确认并行调用结束两点。一般情况下使用的方案为开启新线程调用并使用回调函数的方法处理。这种方法问题在于多线程时对于回调函数的处理线程可能存在安全问题，而且代码量会增加开发的复杂性。综上所述，对于并发编程需要工具进行简单的封装是有必要的。

Future有什么用？

结合上文，Future是一种异步回调的工具，也有一种设计模式是Future模式，两者是指同一类东西。简单的说，当我们new一个Future对象进行异步调用后，程序会假装已经为此Future填充了我们需要的内容，实际上此Future中可能还在等待异步处理结果，而我们并不关心。当需要使用结果时，我们调用isDone方法判断异步调用是否完成，如果完成则可调用get方法获取结果，如果未完成可继续等待或者采用其他手段。我们也称这种：“创建对象->主线程继续向下执行，Future异步调用其他程序->Future获得结果后填充回原对象->程序需要使用时判断是否完成”设计模式是Future模式。

Future是如何实现的？

我们先看原有的这种方式有哪些需要解决的痛点：

开启新线程，run方法没有返回值，不能返回异步调用的结果
回调函数编写复杂增加开发复杂度
对异步调用的处理不够灵活（或者可以说，在调用了run方法之后，我们其实不能控制异步调用情况）

Future解决上述问题的方法：

使用callable接口替换原有的runnable，此接口有返回值，可以返回数据
在异步调用后数据直接返回给callable，可以用isDone方法判断是否处理完成
封装过后编写简便
在实现callable的方法中，用一系列枚举值加强对异步过程的控制，其中包括增加cancel状态，可以取消异步调用。用isCancelled判断是否取消等
使用get方法获取处理结果，如果此时未处理完则同步阻塞等待处理结束，可以设置get的等待超时参数

Guava Futures有什么用？

Futures是对Future的扩展，这个不属于jdk中的jar包对jdk中的Future做了很多功能封装，使用比较简便。

Futures主要有以下Future不能提供的功能：

多任务并发执行，不阻塞当前线程
直接定义回调函数处理异步Future的结果，不阻塞当前线程
将Future对象转化为另一个Future对象

多任务并发执行，不阻塞当前线程

public void should_run_future_tasks_in_parallel() throws Exception {
        ListeningExecutorService service = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(10));
        ListenableFuture<?> task1 = service.submit(new Runnable() {
            public void run() {
                try {
                    Thread.sleep(2000);
                    System.out.println("future task1 done.....");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        ListenableFuture<?> task2 = service.submit(new Runnable() {
            public void run() {
                try {
                    Thread.sleep(2000);
                    System.out.println("future task2 done.....");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        System.out.println("main task done.....");
        Thread.sleep(3000);
    }

直接定义回调函数处理异步Future的结果，不阻塞当前线程

    public void should_call_back_the_future_task() throws Exception {
        ListeningExecutorService service = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(10));
        ListenableFuture<Integer> task = service.submit(new Callable<Integer>() {
            public Integer call() throws Exception {
                Thread.sleep(2000);
                System.out.println("future task done......");
                return 1;
            }
        });
        Futures.addCallback(task, new FutureCallback() {
            public void onSuccess(Object o) {
                System.out.println("异步处理成功,result="+o);
            }

            public void onFailure(Throwable throwable) {
                System.out.println("异步处理失败,e="+throwable);
            }
        });

        System.out.println("main task done.....");
        Thread.sleep(3000);
    }

Future与AIO的异步概念差异

考虑了一下Future与AIO间的区别，想了想，觉得这是两个概念。AIO和NIO中提到的同步异步、阻塞非阻塞是在处理流的角度上讲，AIO是指在线程中进行IO处理，此线程不阻塞且异步等待IO处理完成，没有新线程的创建概念。而Future主要面对多任务多并行中异步操作，此处的异步是指主线程而言。通过Future创建新线程处理操作，此处创建的新线程的处理过程是同步处理，但是我们并不会关心这个线程，所以概念也是对的。