19.jdk源码阅读之FutureTask

已于 2024-07-25 14:32:31 修改
阅读量526 收藏 7
点赞数 8
分类专栏： JDK源码 文章标签： java 开发语言
于 2024-07-25 14:31:34 首次发布
本文为 至真源 原创，转载请注明出处，谢谢！
本文链接：https://blog.csdn.net/yunkongbian2616/article/details/140687389
版权

1. 写在前面

FutureTask 是 Java 并发包中的一个重要类，它实现了 RunnableFuture 接口，结合了 Future 和 Runnable 的特性。FutureTask 通常用于异步任务的执行和结果的获取。
如下几个问题，大家看看有没有思考过，在后面阅读源码的过程中都会解答：

  1. FutureTask 和 Future 有什么区别？
  2. 如何取消一个 FutureTask？
  3. FutureTask 是如何实现线程安全的？
  4. FutureTask 的使用场景有哪些？
  5. FutureTask 和 CompletableFuture 有什么区别？
  6. 如何处理 FutureTask 的异常？
  7. FutureTask 的 run 方法可以多次调用吗？

2. 全局视角

在这里插入图片描述

2.1 Runnable 接口

Runnable 接口是一个函数式接口，定义了一个 run 方法，用于包含需要在新线程中执行的代码。

@FunctionalInterface
public interface Runnable {
    void run();
}

2.2 Future 接口

Future 接口表示一个异步计算的结果，并提供了检查任务状态、获取结果、取消任务等方法。

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}

2.3 RunnableFuture 接口

RunnableFuture 接口继承了 Runnable 和 Future 接口，表示一个既可以作为任务执行（Runnable），又可以获取结果（Future）的任务。

public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

2.4 FutureTask 的关键方法

FutureTask 实现了 RunnableFuture 接口中的所有方法，并提供了一些额外的方法和机制来管理任务的执行和状态。

2.4.1 构造方法

  • FutureTask(Callable callable)：通过 Callable 创建 FutureTask。
  • FutureTask(Runnable runnable, V result)：通过 Runnable 创建 FutureTask，并指定任务完成后的结果。

2.4.2 任务执行

void run()：执行任务，如果任务已完成或已取消则不执行。

2.4.3 结果获取

  • V get()：获取任务的结果，如果任务未完成则阻塞。
  • V get(long timeout, TimeUnit unit)：在指定时间内获取任务的结果。

2.4.4. 任务状态

  • boolean isDone()：检查任务是否已完成。
  • boolean isCancelled()：检查任务是否已取消。
  • boolean cancel(boolean mayInterruptIfRunning)：取消任务。

3. 从使用说起

3.1 使用 FutureTask 执行 Callable 任务

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class FutureTaskExample {
    public static void main(String[] args) {
        // 创建一个 Callable 任务
        Callable<String> callableTask = () -> {
            Thread.sleep(1000); // 模拟耗时操作
            return "Task completed";
        };

        // 创建一个 FutureTask
        FutureTask<String> futureTask = new FutureTask<>(callableTask);

        // 提交给 Executor 执行
        ExecutorService executor = Executors.newSingleThreadExecutor();
        executor.submit(futureTask);

        try {
            // 获取结果（阻塞直到任务完成）
            String result = futureTask.get();
            System.out.println("Result: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}
  1. 创建一个 Callable 任务，模拟一个耗时操作。
  2. 使用 Callable 创建一个 FutureTask 实例。
  3. 将 FutureTask 提交给 ExecutorService 执行。
  4. 通过 FutureTask 的 get 方法获取任务的结果，该方法会阻塞直到任务完成。
  5. 最后关闭 ExecutorService。

3.2 使用 FutureTask 执行 Runnable 任务并获取结果

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class FutureTaskRunnableExample {
    public static void main(String[] args) {
        // 创建一个 Runnable 任务
        Runnable runnableTask = () -> {
            try {
                Thread.sleep(1000); // 模拟耗时操作
                System.out.println("Runnable task completed");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };

        // 使用 Runnable 和结果值创建一个 FutureTask
        FutureTask<String> futureTask = new FutureTask<>(runnableTask, "Task finished");

        // 提交给 Executor 执行
        ExecutorService executor = Executors.newSingleThreadExecutor();
        executor.submit(futureTask);

        try {
            // 获取结果（阻塞直到任务完成）
            String result = futureTask.get();
            System.out.println("Result: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}
  1. 创建一个 Runnable 任务，模拟一个耗时操作。
  2. 使用 Runnable 和任务完成后的结果值创建一个 FutureTask 实例。
  3. 将 FutureTask 提交给 ExecutorService 执行。
  4. 通过 FutureTask 的 get 方法获取任务的结果，该方法会阻塞直到任务完成。
  5. 最后关闭 ExecutorService。

3.3 取消 FutureTask

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class FutureTaskCancelExample {
    public static void main(String[] args) {
        // 创建一个 Callable 任务
        Callable<String> callableTask = () -> {
            Thread.sleep(3000); // 模拟耗时操作
            return "Task completed";
        };

        // 创建一个 FutureTask
        FutureTask<String> futureTask = new FutureTask<>(callableTask);

        // 提交给 Executor 执行
        ExecutorService executor = Executors.newSingleThreadExecutor();
        executor.submit(futureTask);

        try {
            // 等待一段时间后取消任务
            Thread.sleep(1000);
            boolean cancelled = futureTask.cancel(true);
            System.out.println("Task cancelled: " + cancelled);

            // 获取任务状态
            if (!futureTask.isCancelled()) {
                String result = futureTask.get();
                System.out.println("Result: " + result);
            } else {
                System.out.println("Task was cancelled.");
            }
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}
  1. 创建一个 Callable 任务，模拟一个耗时操作。
  2. 使用 Callable 创建一个 FutureTask 实例。
  3. 将 FutureTask 提交给 ExecutorService 执行。
  4. 等待一段时间后，通过 FutureTask 的 cancel 方法取消任务。
  5. 检查任务是否被取消，如果未取消则获取任务结果，否则输出任务已取消的信息。
  6. 最后关闭 ExecutorService。

4. FutureTask 和 Future 有什么区别？

  • Future 是一个接口，表示一个异步计算的结果。
  • FutureTask 是 Future 的一个具体实现，结合了 Future 和 Runnable 的特性，可以被提交给 Executor 执行，也可以直接在线程中执行。

5. 如何取消一个 FutureTask？

可以调用 FutureTask 的 cancel 方法来取消任务：

futureTask.cancel(true);  // 取消任务，true 表示如果任务正在运行，可以中断它

6. FutureTask 是如何实现线程安全的？

FutureTask 使用了内部状态和同步机制来确保线程安全。例如，它使用 CAS 操作和 volatile 变量来管理任务的状态（如未开始、正在运行、已完成、已取消等）。

7. FutureTask 的使用场景有哪些？

  • 异步计算：可以在后台执行耗时任务，并在需要时获取结果。
  • 并行处理：可以将多个任务并行执行，并在所有任务完成后处理结果。
  • 延迟计算：可以延迟执行任务，直到需要结果时再执行。

8. FutureTask 和 CompletableFuture 有什么区别？

  • FutureTask 是 Java 5 引入的，用于表示一个可取消的异步任务。
  • CompletableFuture 是 Java 8 引入的，提供了更丰富的功能，如链式调用、组合多个异步任务、处理异步任务的结果等。

9. 如何处理 FutureTask 的异常？

可以在获取结果时处理异常：

try {
    String result = futureTask.get();
} catch (InterruptedException e) {
    // 处理线程中断异常
} catch (ExecutionException e) {
    // 处理任务执行异常
    Throwable cause = e.getCause();  // 获取实际异常原因
}

10. FutureTask 的 run 方法可以多次调用吗？

FutureTask 的 run 方法只能被调用一次。多次调用 run 方法不会重新执行任务，只会返回相同的结果或状态。

系列文章

1.JDK源码阅读之环境搭建

2.JDK源码阅读之目录介绍

3.jdk源码阅读之ArrayList(上)

4.jdk源码阅读之ArrayList(下)

5.jdk源码阅读之HashMap

6.jdk源码阅读之HashMap（下）

7.jdk源码阅读之ConcurrentHashMap(上)

8.jdk源码阅读之ConcurrentHashMap（下）

9.jdk源码阅读之ThreadLocal

10.jdk源码阅读之ReentrantLock

11.jdk源码阅读之CountDownLatch

12.jdk源码阅读之CyclicBarrier

13.jdk源码阅读之Semaphore

14.jdk源码阅读之线程池(上)

15.jdk源码阅读之线程池(下)

16.jdk源码阅读之ArrayBlockingQueue

17.jdk源码阅读之LinkedBlockingQueue

18.jdk源码阅读之CopyOnWriteArrayList

至真源
关注
  • 8
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
rt.jar JDK1.8源码
02-21
JDK动态代理生成字节码，用到了ProxyGenerator.generateProxyClass()方法，这个是rt.jar包中的方法，而安装JDK之后的src.zip没有包含。苦于找不到源码，下载了一个又报错，代码也不全，这里给大家分享一下亲测可用的...
jdk8源码_rt.zip
12-23
jdk8目录下的源码不包含rt.jar中的源码，本资源只包含rt.jar包的源码，注意：模块的源码不需要下载，你安装好jdk后，会在${JAVA_HOME}的根目录下找到src.zip，这就是src.jar的源码。
JDK源码阅读顺序
weixin_40841731的博客
11-06 165
转至：https://blog.csdn.net/qq_21033663/article/details/79571506   很多java开发的小伙伴都会阅读jdk源码，然而确不知道应该从哪读起。以下为小编整理的通常所需阅读的源码范围。  标题为包名，后面序号为优先级1-4，优先级递减  1、java.lang 1) Object 1 2) String 1 3) AbstractSt...
jdk源码与java源码_JDK源码阅读顺序
weixin_29290379的博客
02-12 154
很多java开发的小伙伴都会阅读jdk源码，然而确不知道应该从哪读起。以下为小编整理的通常所需阅读的源码范围。标题为包名，后面序号为优先级1-4，优先级递减1、java.lang1) Object 12) String 13) AbstractStringBuilder 14) StringBuffer 15) StringBuilder 16) Boolean 27) Byte 28) Doub...
【转载】JDK源码阅读顺序
可耳（keer）的博客
03-31 497
很多java开发的小伙伴都会阅读jdk源码，然而确不知道应该从哪读起。以下为小编整理的通常所需阅读的源码范围。 标题为包名，后面序号为优先级1-4，优先级递减 1. java.lang 1) Object 1 2) String 1 3) AbstractStringBuilder 1 4) StringBuffer 1 5) StringBuilder 1 6) Boolean 2 7) By...
JDK源码——AQS源码
庄小焱
11-24 939
AQS 就是一个抽象类，继承了AbstractOwnableSynchronizer ，主要用来构建锁和同步器。这个类在 java.util.concurrent.locks 包下面，AQS为构建锁和同步器提供了一些通用功能的实现，因此，使用 AQS 能简单且高效地构造出应用广泛的大量的同步器，比如 ReentrantLock，Semaphore，其他的 ReentrantReadWriteLock，SynchronousQueue，FutureTask(jdk1.7) 等等皆是基于 AQS 的。
JDK源码阅读计划
gongsenlin341的博客
07-17 476
计划阅读顺序如下，优先级1-4，完成一个写一篇博客 1、java.lang Object 1 String 1 AbstractStringBuilder 1 StringBuffer 1 StringBuilder 1 Boolean 2 Byte 2 Double 2 Float 2 Integer 2 Long 2 Short 2 Thread 2 ThreadLocal 2 Enum 3 Throwable 3 Error 3 Exception 3 Class 4 ClassLoader 4 C
java的JDK源码阅读顺序整理笔记
宜春
11-02 1524
很多java开发的小伙伴都会阅读jdk源码，然而确不知道应该从哪读起。以下为小编整理的通常所需阅读的源码范围。 标题为包名，后面序号为优先级1-4，优先级递减 文章目录 1、java.lang 2、java.util 3、java.util.concurrent 4、java.util.concurrent.atomic 5、java.lang.reflect 6、java.lang.annotation 7、java.util.concurrent.locks
java jdk native源码_JAVA JDK源码在线阅读
weixin_29830833的博客
02-16 154
Java的版本是1.8.0_111，我把JDK源码发布到了github上，大家看起来也比较方便，地址：下面是转载的JDK源码阅读顺序，原文：https://blog.csdn.net/qq_21033663/article/details/79571506很多java开发的小伙伴都会阅读jdk源码，然而确不知道应该从哪读起。以下为小编整理的通常所需阅读的源码范围。标题为包名，后面序号为优先级1-4...
JAVA JDK源码在线阅读
热门推荐
qingliang4321的专栏
03-05 1万+
Java的版本是1.8.0_111，我把JDK源码发布到了github上，大家看起来也比较方便，地址： https://github.com/daiqingliang/java_jdk1.8.0_111 在提供一个rt.jar包源码的地址（JDK源码中用了很多rt.jar中的类，例如sun.misc.Unsafe类，都包含在rt.jar中）： https://github.com/daiqi...
JDK源码阅读
u013891584的博客
06-28 216
1、java.lang1) Object 1 2) String 1 3) AbstractStringBuilder 1 4) StringBuffer 1 5) StringBuilder 1 6) Boolean 2 7) Byte 2 8) Double 2 9) Float 2 10) Integer 2 11) Long 2 12) Short 2 13) Thread 2 14) T...
jdk1.8 rt.jar 源码
09-28
Java开发工具包（JDK）是Java编程语言的核心组件，其中包含了运行和开发Java应用程序所需的库和工具。在 JDK 1.8 版本中，`rt.jar` 是一个非常重要的文件，它包含了Java标准版（Java SE）的运行时类库。这个库包含了...
jdk8-source(JDK8源码包含rt.jar下所有包)
09-22
jdk8目录下的源码没有rt.jar中的一些包，例如sun包。 在https://download.java.net/openjdk/jdk8/目录下有相关的下载，但是下载太慢(已经下载不到) 这个包不全，暂时关闭
jdk8源码文件.zip
06-03
**Java Development Kit (JDK) 8 源码分析** JDK 8 是 Java 编程语言的一个重要版本，引入了许多新的特性和改进，对于理解Java编程和优化代码至关重要。这个压缩包“jdk8源码文件.zip”包含了JDK 8的源代码，主要...
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1135
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
redis+spring面试题
github_36510643的博客
07-21 406
redis+spring面试题
Java-Lambda
lizhiwei21的博客
07-21 444
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 773
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

至真源

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

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

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

打赏作者

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

抵扣说明：

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

余额充值