如何轻松将抛出checked Exception的Runnable Lambda包装为RuntimeException？

问题背景 #

当你尝试在Runnable Lambda中调用抛出Checked Exception的方法时，会直接出现编译错误——因为Runnable.run()方法的签名不允许抛出Checked Exception。即便外层加了try-catch，也只能捕获RuntimeException，无法处理Checked Exception。

比如这段代码会编译失败：

public static void main(String[] args)
{
    try {
        List<Runnable> runnableList = List.of(
                () -> doSomethingActual(),
                () -> doSomethingActual()
        );

        runnableList.parallelStream().forEach(Runnable::run);

    } catch (Exception e) {
        System.out.println("Exception occured");
    }
}

private static void doSomethingActual () throws Exception {
    someActionThatCanThrowAnException();
}

如果为每个方法单独写重复的try-catch包装代码，会显得冗余且不优雅：

private static void doSomethingThatWorks() throws RuntimeException {
    try {
        doSomethingActual();
    } catch (Exception e) {
        throw new RuntimeException("Test exception here");
    }
}

优雅解决方案 #

方案1：自定义带Checked Exception的函数式接口 + 通用包装方法 #

首先定义一个支持抛出Checked Exception的替代接口：

@FunctionalInterface
public interface CheckedRunnable {
    void run() throws Exception;
}

然后编写通用包装方法，将CheckedRunnable转换为标准Runnable，同时把Checked Exception包装成RuntimeException：

private static Runnable wrapChecked(CheckedRunnable runnable) {
    return () -> {
        try {
            runnable.run();
        } catch (Exception e) {
            throw new RuntimeException("Wrapped checked exception", e);
        }
    };
}

使用时只需用wrapChecked包装每个Lambda即可，代码简洁无重复：

public static void main(String[] args) {
    try {
        List<Runnable> runnableList = List.of(
                wrapChecked(() -> doSomethingActual()),
                wrapChecked(() -> doSomethingActual())
        );

        runnableList.parallelStream().forEach(Runnable::run);
    } catch (RuntimeException e) {
        System.out.println("Exception occurred: " + e.getMessage());
    }
}

方案2：Stream中直接转换（无需额外接口） #

如果不想新增接口，可以在Stream处理阶段直接完成包装转换，省去单独创建Runnable列表的步骤：

public static void main(String[] args) {
    try {
        // 直接创建带Checked Exception的任务列表
        List<CheckedRunnable> checkedTasks = List.of(
                () -> doSomethingActual(),
                () -> doSomethingActual()
        );

        checkedTasks.parallelStream()
                .map(task -> (Runnable) () -> {
                    try {
                        task.run();
                    } catch (Exception e) {
                        throw new RuntimeException("Wrapped exception", e);
                    }
                })
                .forEach(Runnable::run);
    } catch (RuntimeException e) {
        System.out.println("Exception occurred: " + e.getMessage());
    }
}

方案3：简化版静态工具方法（无需自定义公开接口） #

如果觉得自定义公开接口麻烦，可以用私有内部接口配合类型推断：

private static Runnable wrap(RunnableWithException runnable) {
    return () -> {
        try {
            runnable.run();
        } catch (Exception e) {
            throw new RuntimeException("Test exception here", e);
        }
    };
}

// 私有内部接口，仅用于类型推断
private interface RunnableWithException {
    void run() throws Exception;
}

使用方式和方案1完全一致，接口仅在内部使用，不对外暴露。

关键说明 #

• 所有方案的核心都是将Checked Exception包装为RuntimeException，绕过Runnable的签名限制。
• 务必保留原始异常作为cause传入RuntimeException，便于后续排查问题（不要丢弃原始异常）。

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