使用 `FutureTask` 实现超时控制

在多线程编程中，异步任务的执行常常是一个重要的需求。当一个任务的执行时间不可预测时，能够对其设置超时控制是很有用的。Java 提供了 FutureTask 类，它不仅可以用来处理异步任务，还能有效地管理任务的超时。本文将详细介绍如何使用 FutureTask 实现超时控制，包括 FutureTask 的基本概念、创建异步任务、设置超时，以及处理超时情况。

1. 基本概念

1.1 FutureTask 类

FutureTask 是 Java 并发包 java.util.concurrent 中的一个类，实现了 Runnable 和 Future 接口。它用于包装一个可以通过 Future 接口获取结果的异步任务，并且支持在任务完成前取消任务。

public class FutureTask<V> extends Object implements RunnableFuture<V>

• Runnable：允许 FutureTask 作为一个线程任务提交给线程池执行。
• Future：提供获取任务结果、取消任务等功能。

1.2 Future 接口

Future 接口提供了一种异步任务的抽象，它的主要功能包括：

• 获取任务结果：通过 get() 方法获取任务的返回结果。
• 检查任务是否完成：通过 isDone() 方法检查任务是否已完成。
• 取消任务：通过 cancel(boolean mayInterruptIfRunning) 方法取消任务。

2. 创建 FutureTask 实例

为了创建一个 FutureTask 实例，我们需要提供一个实现了 Callable 接口的任务类。Callable 接口与 Runnable 类似，但允许任务返回一个结果并且能够抛出异常。

2.1 实现 Callable 接口

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        // 模拟长时间运行的任务
        Thread.sleep(5000);
        return "Task Completed";
    }
}

2.2 创建 FutureTask 实例

import java.util.concurrent.FutureTask;

public class FutureTaskExample {
    public static void main(String[] args) {
        MyCallable callable = new MyCallable();
        FutureTask<String> futureTask = new FutureTask<>(callable);

        // 提交任务到线程池
        Thread thread = new Thread(futureTask);
        thread.start();
        
        // 进一步操作...
    }
}

3. 设置超时控制

为了在异步任务执行时设置超时，我们可以使用 FutureTask 的 get 方法，该方法有两个重载版本，一个可以指定等待时间，一个不指定时间。我们可以利用这个特性来实现超时控制。

3.1 get 方法的重载

• get()：阻塞直到任务完成并获取结果，但没有超时控制。
• get(long timeout, TimeUnit unit)：阻塞直到任务完成或者超时，超时后抛出 TimeoutException。

3.2 使用 get(long timeout, TimeUnit unit) 设置超时

import java.util.concurrent.*;

public class FutureTaskTimeoutExample {
    public static void main(String[] args) {
        MyCallable callable = new MyCallable();
        FutureTask<String> futureTask = new FutureTask<>(callable);
        Thread thread = new Thread(futureTask);
        thread.start();

        try {
            // 设置超时时间为 3 秒
            String result = futureTask.get(3, TimeUnit.SECONDS);
            System.out.println("Result: " + result);
        } catch (TimeoutException e) {
            System.out.println("Task timed out");
            futureTask.cancel(true); // 尝试取消任务
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 保持中断状态
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

4. 处理超时

在设置了超时后，如果任务未完成，将抛出 TimeoutException。在捕获到 TimeoutException 后，我们可以采取适当的措施，如取消任务或记录日志。FutureTask 的 cancel(boolean mayInterruptIfRunning) 方法可以用来尝试取消任务。需要注意的是，取消任务的实际效果取决于任务的实现，特别是任务是否可以响应中断。

4.1 取消任务

futureTask.cancel(true); // 尝试取消任务

• mayInterruptIfRunning 参数：如果为 true，则如果任务正在执行中，将会中断线程；如果为 false，则任务将在完成当前步骤后停止。

4.2 中断处理

如果任务可以中断，必须在任务中检查中断状态，并在合适的地方响应中断。

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 10; i++) {
            if (Thread.currentThread().isInterrupted()) {
                throw new InterruptedException("Task was interrupted");
            }
            Thread.sleep(1000);
        }
        return "Task Completed";
    }
}

5. 总结

FutureTask 提供了一种有效的方式来处理异步任务并实现超时控制。通过使用 FutureTask 和 Callable，我们可以将长时间运行的任务交给线程池执行，同时利用 get(long timeout, TimeUnit unit) 方法设置超时，确保任务不会无限期阻塞。在处理超时时，我们可以通过捕获 TimeoutException 来采取适当的措施，例如取消任务或处理异常。理解这些机制可以帮助我们编写更可靠和高效的多线程代码。