并行运行JUnit5参数化测试时间歇性触发ParameterResolutionException

一、JUnit5并行配置 #

junit.jupiter.execution.parallel.enabled = true
junit.jupiter.execution.parallel.mode.default = concurrent
junit.jupiter.execution.parallel.mode.classes.default = concurrent
junit.jupiter.execution.parallel.config.dynamic.factor = 2

二、测试代码片段 #

import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;

@ExtendWith(SimpleCallbackListener.class)
public class HelloWorldTest {
    private static final Map<String, List<TestData>> testDataMap;

    static {
        testDataMap = TestsConfigManager.readTestConfig("test-data");
    }

    private static List<Object[]> data() {
        final List<Object[]> testDataList = prepareTestData(testDataMap);
        return testDataList;
    }

    @ParameterizedTest(name = "{index}: {0}")
    @MethodSource("data")
    @Tag("regression")
    public void testMethodName(
            final String expected,
            final String actual
    ) {
        // 测试逻辑
    }
}

三、SimpleCallbackListener实现 #

public class SimpleCallbackListener implements BeforeAllCallback, ExtensionContext.Store.CloseableResource {
    /**
     * 防止同一流程多线程执行的锁
     */
    private static final Lock LOCK = new ReentrantLock();
    private static boolean started = false;
    private Instant startTime;

    @Override
    public void beforeAll(final ExtensionContext context) {
        LOCK.lock();
        try {
            if (!started) {
                startTime = Instant.now();
                requireApplicationInitializer();
                // 注册根测试上下文关闭时的回调钩子
                context.getRoot().getStore(GLOBAL).put(this.getClass().getName(), this);
                started = true;
            }
        } finally {
            LOCK.unlock();
        }
    }
}

四、间歇性抛出的异常 #

org.junit.jupiter.api.extension.ParameterResolutionException: No ParameterResolver registered for parameter ... in method ...
    at java.base@17.0.7/java.util.concurrent.RecursiveAction.exec(RecursiveAction.java:194)
    at java.base@17.0.7/java.util.concurrent.ForkJoinTask.doExec(ForkJoinTask.java:373)
    at java.base@17.0.7/java.util.concurrent.ForkJoinPool$WorkQueue.topLevelExec(ForkJoinPool.java:1182)
    at java.base@17.0.7/java.util.concurrent.ForkJoinPool.scan(ForkJoinPool.java:1655)
    at java.base@17.0.7/java.util.concurrent.ForkJoinPool.runWorker(ForkJoinPool.java:1622)
    at java.base@17.0.7/java.util.concurrent.ForkJoinWorkerThread.run(ForkJoinWorkerThread.java:165)

已尝试的无效方案 #

• 排查过非参数化测试触发该异常的相关场景
• 参考过JUnit5参数解析器缺失的常规解决方案
  以上方案均未解决间歇性异常问题

问题分析与修复方案 #

核心原因 #

异常本质是并行执行时，测试数据加载流程与全局初始化逻辑存在竞态条件：

1. 类级并行开启后，多个测试类会同时启动，HelloWorldTest的静态代码块、data()方法可能在SimpleCallbackListener完成应用初始化前就执行
2. 若readTestConfig或prepareTestData依赖未初始化的上下文，会返回无效测试数据（比如空列表、参数类型不匹配），导致JUnit无法找到对应参数解析器
3. 监听器中静态变量started的线程安全实现不严谨，多测试类场景下可能导致初始化逻辑未执行完全

修复方案 #

方案1：强制测试数据加载等待初始化完成

修改HelloWorldTest静态代码块，添加初始化等待逻辑：

private static final Map<String, List<TestData>> testDataMap;

static {
    // 等待全局初始化完成
    while (!SimpleCallbackListener.isInitialized()) {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException(e);
        }
    }
    testDataMap = TestsConfigManager.readTestConfig("test-data");
}

同时在SimpleCallbackListener中添加初始化状态查询方法：

public static boolean isInitialized() {
    LOCK.lock();
    try {
        return started;
    } finally {
        LOCK.unlock();
    }
}

方案2：调整并行执行策略

若无需类级并行，修改配置降低并行粒度：

junit.jupiter.execution.parallel.mode.classes.default = same_thread

该配置保留方法级并行，同时确保同一测试类的静态代码块、初始化逻辑串行执行，避免竞态。

方案3：改用JUnit全局存储管理初始化状态

替换监听器中的静态变量，使用JUnit扩展上下文的全局存储实现线程安全的初始化判断：

public class SimpleCallbackListener implements BeforeAllCallback, ExtensionContext.Store.CloseableResource {
    private static final String INITIALIZED_KEY = "initialized";
    private Instant startTime;

    @Override
    public void beforeAll(final ExtensionContext context) {
        ExtensionContext.Store globalStore = context.getRoot().getStore(GLOBAL);
        // 全局存储原子操作判断是否已初始化
        if (Boolean.TRUE.equals(globalStore.get(INITIALIZED_KEY, Boolean.class))) {
            return;
        }
        try {
            startTime = Instant.now();
            requireApplicationInitializer();
            globalStore.put(INITIALIZED_KEY, Boolean.TRUE);
            globalStore.put(this.getClass().getName(), this);
        } catch (Exception e) {
            globalStore.put(INITIALIZED_KEY, Boolean.FALSE);
            throw e;
        }
    }
}

方案4：确保测试数据方法线程安全

若prepareTestData或readTestConfig非线程安全，添加同步控制：

private static List<Object[]> data() {
    synchronized (HelloWorldTest.class) {
        final List<Object[]> testDataList = prepareTestData(testDataMap);
        return testDataList;
    }
}

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