自定义CompletableFuture子类类型转换异常求助

类型转换异常原因 #

你遇到的类型转换异常，是因为Spring的@Async注解在处理返回Future的方法时，会自动将你返回的自定义FutureImpl包装成Spring内部的CompletableFuture实现类（比如AsyncResult或代理类）。因此在调用方强制转换为FutureImpl时，必然会出现类型不匹配的错误。

另外，你的FutureImpl.cancel()方法存在逻辑错误：调用Thread.currentThread().interrupt()中断的是执行cancel()的线程（也就是测试方法testService的线程），而非执行异步任务的线程，根本无法达到中断任务的目的。

正确实现超时中断的方案 #

方案1：使用ExecutorService.submit() + Future.cancel(true) #

这是最直接的方案，利用JDK原生的ExecutorService提交任务，返回的Future支持通过cancel(true)中断执行任务的线程（前提是任务逻辑响应中断）。

步骤1：配置线程池

首先在Spring中配置自定义线程池：

@Configuration
public class AsyncConfig {
    @Bean(name = "taskExecutor")
    public ExecutorService taskExecutor() {
        return Executors.newFixedThreadPool(5);
    }
}

步骤2：修改业务方法

在WorkerService中注入线程池，提交可中断的任务：

@Service
public class WorkerService {
    @Autowired
    @Qualifier("taskExecutor")
    private ExecutorService executor;

    public Future<String> process() {
        return executor.submit(() -> {
            try {
                // 模拟长时间任务，需响应中断
                while (!Thread.currentThread().isInterrupted()) {
                    // 执行核心业务逻辑
                    Thread.sleep(1000); // 响应中断的阻塞方法
                    System.out.println("任务执行中...");
                }
                return "RESULT";
            } catch (InterruptedException e) {
                // 中断时抛出异常，终止任务
                throw new InterruptedException("任务被超时中断");
            }
        });
    }
}

步骤3：测试方法

在测试接口中调用get()并处理超时中断：

@RestController
public class TestController {
    @Autowired
    private WorkerService workerService;

    @GetMapping("/test")
    public void testService() {
        Future<String> future = workerService.process();

        try {
            String result = future.get(5, TimeUnit.SECONDS);
            System.out.println("任务结果：" + result);
        } catch (InterruptedException | ExecutionException e) {
            System.out.println("任务执行异常：" + e.getMessage());
        } catch (TimeoutException e) {
            boolean isCancelled = future.cancel(true);
            System.out.println("任务超时，尝试中断：" + (isCancelled ? "成功" : "失败"));
        }
    }
}

方案2：CompletableFuture结合线程追踪 #

如果必须使用CompletableFuture，需要在任务内部追踪执行线程，超时后手动中断：

@Service
public class WorkerService {
    @Autowired
    @Qualifier("taskExecutor")
    private ExecutorService executor;

    public CompletableFuture<String> process() {
        CompletableFuture<String> resultFuture = new CompletableFuture<>();

        executor.execute(() -> {
            Thread taskThread = Thread.currentThread();
            try {
                while (!taskThread.isInterrupted()) {
                    // 业务逻辑
                    Thread.sleep(1000);
                    System.out.println("任务执行中...");
                }
                resultFuture.complete("RESULT");
            } catch (InterruptedException e) {
                resultFuture.completeExceptionally(new InterruptedException("任务被中断"));
                // 保留中断状态
                taskThread.interrupt();
            } catch (Exception e) {
                resultFuture.completeExceptionally(e);
            }

            // 超时钩子：5秒后未完成则中断线程
            resultFuture.orTimeout(5, TimeUnit.SECONDS)
                    .exceptionally(ex -> {
                        if (ex instanceof TimeoutException) {
                            taskThread.interrupt();
                        }
                        return null;
                    });
        });

        return resultFuture;
    }
}

关键注意事项 #

• 任务必须响应中断：如果任务是无检查的死循环，即使调用interrupt()也无法终止。必须在任务中定期检查Thread.currentThread().isInterrupted()，或使用响应中断的阻塞方法（如Thread.sleep()、Object.wait()）。
• 避免自定义CompletableFuture子类：Spring@Async会包装返回的Future，导致类型转换异常，且无法有效拦截cancel()方法。

内容的提问来源于stack exchange，提问作者Thorvas