Java中FutureTask使用方法

FutureTask

Callable

Runnable

Future

Runnable

FutureTask

Callable

import java.util.concurrent.*;

// 1. 定义你的异步任务，这里我们用Callable，因为它能返回结果
class MyCallableTask implements Callable<String> {
    private final String taskName;
    private final long delayMillis;

    public MyCallableTask(String taskName, long delayMillis) {
        this.taskName = taskName;
        this.delayMillis = delayMillis;
    }

    @Override
    public String call() throws Exception {
        System.out.println(Thread.currentThread().getName() + " - " + taskName + " 开始执行...");
        try {
            TimeUnit.MILLISECONDS.sleep(delayMillis); // 模拟耗时操作
        } catch (InterruptedException e) {
            System.out.println(Thread.currentThread().getName() + " - " + taskName + " 被中断。");
            Thread.currentThread().interrupt(); // 重新设置中断标志
            throw new InterruptedException("任务 " + taskName + " 被中断");
        }
        String result = "任务 " + taskName + " 完成，耗时 " + delayMillis + "ms。";
        System.out.println(Thread.currentThread().getName() + " - " + result);
        return result;
    }
}

public class FutureTaskExample {
    public static void main(String[] args) {
        // 2. 创建一个Callable实例
        MyCallableTask callableTask = new MyCallableTask("数据处理任务", 2000);

        // 3. 将Callable包装成FutureTask
        FutureTask<String> futureTask = new FutureTask<>(callableTask);

        // 4. 提交FutureTask到一个ExecutorService（推荐方式）
        // 或者也可以在一个新的线程中直接运行 futureTask.run();
        ExecutorService executor = Executors.newFixedThreadPool(2);
        executor.submit(futureTask); // submit方法会返回一个Future，但我们已经有了FutureTask实例

        System.out.println("主线程已提交任务，正在做其他事情...");

        try {
            // 5. 获取任务结果，get()方法会阻塞直到任务完成
            String result = futureTask.get(); // 也可以使用带超时参数的get(timeout, unit)
            System.out.println("主线程获取到结果: " + result);

            // 尝试取消一个任务（如果它还没开始或没完成）
            MyCallableTask anotherTask = new MyCallableTask("耗时计算任务", 5000);
            FutureTask<String> anotherFutureTask = new FutureTask<>(anotherTask);
            executor.submit(anotherFutureTask);
            System.out.println("尝试取消另一个任务...");
            boolean cancelled = anotherFutureTask.cancel(true); // true表示如果任务正在运行，尝试中断它
            System.out.println("任务是否被取消: " + cancelled);

            // 检查被取消任务的状态
            System.out.println("被取消任务是否完成: " + anotherFutureTask.isDone());
            System.out.println("被取消任务是否真的被取消: " + anotherFutureTask.isCancelled());

            try {
                // 尝试获取被取消任务的结果，会抛出CancellationException
                anotherFutureTask.get();
            } catch (CancellationException e) {
                System.out.println("意料之中：被取消的任务抛出了CancellationException。");
            }

        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.err.println("主线程等待任务时被中断: " + e.getMessage());
        } catch (ExecutionException e) {
            System.err.println("任务执行过程中发生异常: " + e.getCause().getMessage());
        } finally {
            executor.shutdown(); // 关闭线程池
        }
    }
}

FutureTask

get()

get()

CancellationException

get()

ExecutionException

getCause()

FutureTask

Thread

wait/notify

FutureTask

FutureTask

get()

isDone()

isCancelled()

Thread

cancel(true)

InterruptedException

Thread.interrupt()

FutureTask

FutureTask

ExecutorService

FutureTask

new Thread()

FutureTask

Callable

FutureTask

futureTask.get()

ExecutionException

get()

// 假设有一个会抛出异常的Callable
class FailingTask implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println("FailingTask 正在执行...");
        throw new RuntimeException("Oops! 任务执行失败了！");
    }
}

// 在主线程中
ExecutorService executor = Executors.newSingleThreadExecutor();
FutureTask<String> failingFutureTask = new FutureTask<>(new FailingTask());
executor.submit(failingFutureTask);

try {
    String result = failingFutureTask.get();
    System.out.println("任务成功: " + result);
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
    System.err.println("主线程被中断: " + e.getMessage());
} catch (ExecutionException e) {
    // 捕获ExecutionException，并通过getCause()获取原始异常
    System.err.println("任务执行异常，原始错误: " + e.getCause().getMessage());
    // 这里可以根据e.getCause()的类型进行不同的处理，比如日志记录、重试、返回默认值等
} finally {
    executor.shutdown();
}

getCause()

FutureTask

get(long timeout, TimeUnit unit)

get()

TimeoutException

// 假设有一个耗时较长的Callable
class LongRunningTask implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println("LongRunningTask 正在执行...");
        TimeUnit.SECONDS.sleep(5); // 模拟5秒耗时
        return "LongRunningTask 完成。";
    }
}

// 在主线程中
ExecutorService executor = Executors.newSingleThreadExecutor();
FutureTask<String> longRunningFutureTask = new FutureTask<>(new LongRunningTask());
executor.submit(longRunningFutureTask);

try {
    // 设置2秒的超时时间
    String result = longRunningFutureTask.get(2, TimeUnit.SECONDS);
    System.out.println("任务成功: " + result);
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
    System.err.println("主线程被中断: " + e.getMessage());
} catch (ExecutionException e) {
    System.err.println("任务执行异常: " + e.getCause().getMessage());
} catch (TimeoutException e) {
    System.err.println("任务执行超时！");
    // 任务超时后，你可以选择取消它，防止它继续占用资源
    boolean cancelled = longRunningFutureTask.cancel(true);
    System.out.println("任务超时后是否尝试取消: " + cancelled);
} finally {
    executor.shutdown();
}

TimeoutException

cancel(true)

FutureTask

CompletableFuture

CompletableFuture