使用ScheduledExecutorService执行严重变慢，求优化及替代方案

问题描述 #

我需要限制部分方法的执行时间，因此使用ScheduledExecutorService实现超时控制，而非引入并发。相关代码如下：

public class Task {
    private static final ScheduledExecutorService scheduler = Executors
            .newScheduledThreadPool(1);

    public abstract Callable<Result> getCallable(Target target);

    public Result processTarget(Target target) {
        try {
            ScheduledFuture<List<Result>> future = scheduler.schedule(
                        getCallable(target), 10, TimeUnit.SECONDS);
            return future.get();
        } catch (InterruptedException | ExecutionException e) {
            throw new RuntimeException(e);
        }
    }
}  

该代码功能正常，但性能表现极差：部分子类实现中，即便直接调用Callable仅需数毫秒，future.get()却耗时10秒；增大线程池规模也无改善。

以PmdGrader子类为例，其Callable用于程序化执行PMD：

public class PmdGrader extends Task {
    @Override
    public Callable<Result> getCallable(final Target target) {
        return () -> {
            try (PmdAnalysis analysis = createAnalysis()) {
                analysis.files().addFileOrDirectory(target.toPath());
                Report report = analysis.performAnalysisAndCollectReport();
                return produceResults(report);
            }
        };
    }
}

未引入ScheduledExecutorService时，PmdGrader相关单元测试耗时13-696毫秒；引入后，部分测试耗时不变，部分则比原时长增加约10秒。若将超时时间改为15秒，这些测试耗时会额外增加5秒——超时时间反而成了最小执行时长，与预期的最大时长不符。

现提出两个问题：

1. 能否在使用ScheduledExecutorService的同时避免该性能损耗？
2. 是否有更合适的Java内置或第三方库可替代？

解答 #

问题1：修复ScheduledExecutorService的性能问题 #

你用错了ScheduledExecutorService的核心API——schedule()方法的作用是延迟指定时间后再执行任务，而非为任务设置超时上限。这就是为什么任务总耗时等于或超过超时时间：任务会先等待10秒才开始执行，再加上自身的执行时间，自然出现了“超时变最小执行时长”的异常。

要实现正确的超时控制，应该改用普通ExecutorService提交任务，然后通过Future.get(long timeout, TimeUnit unit)方法设置超时：

public class Task {
    private static final ExecutorService executor = Executors.newFixedThreadPool(1);

    public abstract Callable<Result> getCallable(Target target);

    public Result processTarget(Target target) {
        try {
            Future<Result> future = executor.submit(getCallable(target));
            // 最多等待10秒获取结果，超时抛出TimeoutException
            return future.get(10, TimeUnit.SECONDS);
        } catch (InterruptedException | ExecutionException e) {
            throw new RuntimeException(e);
        } catch (TimeoutException e) {
            // 可在此处取消任务、返回默认结果或抛出自定义异常
            future.cancel(true); // 中断正在执行的任务（需任务代码响应中断）
            throw new RuntimeException("任务执行超时", e);
        }
    }
}

调整后任务会立即执行，只有当任务自身执行时间超过10秒时才会触发超时，完全符合预期的“最大执行时长”控制逻辑。

问题2：替代方案 #

Java内置方案

• ExecutorService + Future.get(timeout)：如上述代码，是最简单直接的内置方案，无需额外依赖，满足基础超时控制需求。
• CompletableFuture（Java 8+）：支持更灵活的异步编程模型，通过orTimeout方法可快速实现超时控制，还支持链式调用、异常处理等复杂场景：

public Result processTarget(Target target) {
    try {
        return CompletableFuture.supplyAsync(() -> {
            try {
                return getCallable(target).call();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }, executor)
        .orTimeout(10, TimeUnit.SECONDS)
        .get();
    } catch (InterruptedException | ExecutionException e) {
        throw new RuntimeException(e);
    } catch (TimeoutException e) {
        throw new RuntimeException("任务执行超时", e);
    }
}

第三方库

• Guava ListenableFuture：适合已使用Guava的项目，结合Futures.withTimeout方法实现超时控制，支持异步回调：

public Result processTarget(Target target) {
    ListeningExecutorService executor = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(1));
    ListenableFuture<Result> future = executor.submit(getCallable(target));
    try {
        return Futures.withTimeout(future, 10, TimeUnit.SECONDS);
    } catch (TimeoutException | InterruptedException | ExecutionException e) {
        throw new RuntimeException(e);
    } finally {
        executor.shutdown();
    }
}

• Apache Commons Lang TimeoutCallable：可直接包装原Callable实现超时控制，代码简洁易读：

public Result processTarget(Target target) throws Exception {
    TimeoutCallable<Result> timeoutCallable = new TimeoutCallable<>(getCallable(target), 10, TimeUnit.SECONDS);
    return timeoutCallable.call();
}

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