当前位置:   article > 正文

19.jdk源码阅读之FutureTask

19.jdk源码阅读之FutureTask

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();
}
  • 1
  • 2
  • 3
  • 4

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;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

2.3 RunnableFuture 接口

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

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

  • 1
  • 2
  • 3
  • 4

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
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  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
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  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
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  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 表示如果任务正在运行,可以中断它
  • 1

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();  // 获取实际异常原因
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

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

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/我家自动化/article/detail/887976
推荐阅读
相关标签
  

闽ICP备14008679号