如何在JVM中对任意代码强制执行严格超时？

问题场景 #

我维护一个多线程服务，需要并行执行用户提交的不受控代码。希望实现一套超时机制，满足以下要求：

• 在限定时间内可恢复地跳过无响应任务，继续执行后续逻辑；
• 彻底终止陷入无响应状态的线程并释放所有资源，避免资源饥饿。

当前方案的局限 #

我尝试用Virtual Thread实现超时处理，代码如下：

public static String maybeTimeout(Callable<String> task, long timeOutMs) {
    try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
        Future<String> taskFuture = executor.submit(task);

        try {
            return taskFuture.get(timeOutMs, TimeUnit.MILLISECONDS);
        } catch (Exception e) {
            taskFuture.cancel(true);
            System.out.println("Timed out!");
            return "Timed out";
        }
    }
}

这个方案对主动让步的代码（比如包含Thread.sleep()的循环）有效，例如：

public static Boolean sneakyTrue() {
    return true;
}

public static String sleepy() {
    return maybeTimeout(
            () -> {
                var x = 0;
                while (sneakyTrue()) {
                    x = x + 1;
                    System.out.println("Sleeping again: " + x);
                    Thread.sleep(1000);
                }
                return "Unreachable";
            },
            5000);
}

但对自旋类无让步代码完全无效，比如：

public static String spinny() {
    return maybeTimeout(
            () -> {
                var x = 0;
                var y = 0;
                while (sneakyTrue()) {
                    x = x + 1;
                    if (x == 0) {
                        System.out.println("Spinning another maxInt times:" + y);
                        y = y + 1;
                    }
                }
                return "Unreachable";
            },
            5000);
}

测试验证 #

用JUnit测试验证了上述行为：

import org.junit.jupiter.api.Test;
import java.util.concurrent.*;

// 省略类定义...

@Test
void sleepyShouldBeAbleToTimeout() {
    assert (sleepy().equals("Timed out"));
    try {
        Thread.sleep(10 * 1000);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
}

@Test
void spinnyShouldBeAbleToTimeout() {
    assert (spinny().equals("Timed out"));
    try {
        Thread.sleep(10 * 1000);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
}

测试显示两个用例都“通过”，但spinny对应的线程在超时后仍持续运行并打印日志，而sleepy的线程会被快速终止。大量这类无响应线程会引发资源饥饿，急需更严格的终止机制。

可行解决方案：进程级隔离 #

Java的线程模型（包括Virtual Thread）本质是协作式中断——只有当线程主动检查中断状态（比如调用Thread.sleep()、wait()这类会抛出InterruptedException的方法）时，cancel(true)才能生效。自旋代码不会主动让步或检查中断，所以无法被Virtual Thread的超时机制终止。

要彻底解决这个问题，必须用操作系统进程级隔离，核心思路是：

• 把用户代码放到独立的子进程中执行，而非线程；
• 超时后直接杀死整个子进程，确保资源被操作系统完全回收。

具体实现步骤 #

1. 封装用户代码为可执行程序：将用户提交的代码编译成独立的Java程序（或其他可执行文件），或用ProcessBuilder直接启动新的JVM进程运行用户代码。
2. 进程超时控制：启动子进程后，用Process.waitFor(timeout, unit)等待执行完成，超时则调用Process.destroy()（或destroyForcibly()）强制终止进程。
3. 结果传递：通过标准输入输出、文件或IPC机制在主进程和子进程间传递任务输入和执行结果。

示例代码（简化版） #

public static String runUserCodeWithTimeout(String userCodeJarPath, long timeoutMs) throws IOException, InterruptedException {
    // 启动子进程运行用户代码
    ProcessBuilder pb = new ProcessBuilder("java", "-jar", userCodeJarPath);
    pb.redirectErrorStream(true);
    Process process = pb.start();

    // 等待超时
    boolean finished = process.waitFor(timeoutMs, TimeUnit.MILLISECONDS);
    if (!finished) {
        // 强制终止进程
        process.destroyForcibly();
        return "Timed out";
    }

    // 读取子进程输出
    String result = new String(process.getInputStream().readAllBytes());
    return result.trim();
}

额外注意事项 #

• 资源限制：可通过ProcessBuilder或操作系统工具（如ulimit、cgroups）限制子进程的CPU、内存等资源，避免恶意代码耗尽系统资源；
• 性能权衡：进程启动开销比线程大，可通过进程池复用子进程，减少频繁创建销毁的成本；
• 安全性：子进程需要严格的权限控制，避免用户代码访问敏感资源。

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