Java多线程系列——Future接口

最新推荐文章于 2024-05-07 11:39:23 发布

飞影铠甲

最新推荐文章于 2024-05-07 11:39:23 发布

阅读量462

点赞数 16

分类专栏： Java 文章标签： java 开发语言算法 c++

本文链接：https://blog.csdn.net/m0_63080216/article/details/137649953

版权

Java 专栏收录该内容

32 篇文章 3 订阅

订阅专栏

引言

在现代软件开发中，多线程编程是提高应用性能和响应速度的重要手段。Java作为一门成熟的编程语言，提供了强大的多线程支持。本文将深入探讨Java多线程中的Future模式，包括其定义、工作原理、使用场景及优缺点分析。

1. Future简介

Future模式是一种在并发编程中广泛使用的设计模式，用于表示一个可能还没有完成的异步操作的结果。在Java中，Future接口在java.util.concurrent包下，是对将来某个时刻计算结果的封装。

2. Future的工作原理

在Java中，当我们需要执行一个耗时的操作时，可以将这个操作提交给一个ExecutorService（执行服务），执行服务会异步地执行这个操作。在提交任务时，它会返回一个Future对象，通过这个对象，我们可以了解任务的状态（是否完成），并且在任务完成后获取其结果。

ExecutorService executor = Executors.newCachedThreadPool();
Future<String> future = executor.submit(() -> {
    // 模拟耗时操作
    Thread.sleep(2000);
    return "操作结果";
});

3. Future接口的主要方法

boolean cancel(boolean mayInterruptIfRunning): 尝试取消执行此任务。
boolean isCancelled(): 如果任务在完成前被取消，则返回 true。
boolean isDone(): 如果任务完成，则返回 true。
V get(): 等待计算完成，然后检索其结果。
V get(long timeout, TimeUnit unit): 如果需要，最多等待指定的时间才能检索结果，然后检索其结果。

4. 使用场景

异步执行耗时操作，不阻塞主线程。
执行多个并行任务，并在所有任务完成后获取结果。
需要取消或检查长时间运行任务的执行状态。

下面是一个使用Future来管理异步任务的详细示例。我们将创建一个模拟的场景，其中包括异步执行几个耗时的操作，这些操作将并行执行，而主线程将继续运行而不被阻塞。完成这些操作后，主线程将检查这些异步任务的状态，并获取它们的结果。

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

public class FutureExample {
    public static void main(String[] args) throws Exception {
        // 创建一个线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);

        // 创建任务列表
        List<Callable<String>> taskList = new ArrayList<>();
        taskList.add(() -> {
            TimeUnit.SECONDS.sleep(2); // 模拟耗时操作
            return "任务1完成";
        });
        taskList.add(() -> {
            TimeUnit.SECONDS.sleep(4); // 模拟更长时间的耗时操作
            return "任务2完成";
        });
        taskList.add(() -> {
            TimeUnit.SECONDS.sleep(3); // 模拟耗时操作
            return "任务3完成";
        });

        // 提交所有任务，并保留Future列表以跟踪它们的状态
        List<Future<String>> futures = new ArrayList<>();
        for (Callable<String> task : taskList) {
            Future<String> future = executor.submit(task);
            futures.add(future);
        }

        // 在这里，主线程可以继续执行其他任务，而不会被阻塞

        // 获取每个任务的结果
        for (Future<String> future : futures) {
            // get()会阻塞直到任务完成
            String result = future.get(); // 可以用future.get(timeout, TimeUnit)来设置超时
            System.out.println(result);
        }

        // 关闭ExecutorService
        executor.shutdown();
    }
}

示例中包含几个关键点：

异步执行耗时操作：我们通过将任务提交给ExecutorService来异步执行耗时操作。这些任务是并行执行的，且不会阻塞主线程的继续执行。
执行多个并行任务：通过创建任务列表并提交给线程池，我们可以轻松实现多个任务的并行执行。
获取任务结果：每个任务的执行结果通过一个Future对象进行跟踪。使用Future.get()方法可以获取任务的执行结果。如果任务尚未完成，这个方法会阻塞直到任务完成。
检查任务状态：我们可以通过Future对象检查任务是否已完成（isDone()）或是否被取消（isCancelled()）。