多线程场景下Mock调用验证间歇性错误排查求助

这个问题我之前也碰到过，核心就是异步任务和测试主线程的时序不匹配：你的测试代码在调用foo()后立刻去验证m_service.execute()的调用，但此时异步线程可能还没执行到这个方法，导致验证失败；而有时候异步线程跑得够快，测试就通过了，这就是“间歇性”错误的根源。

下面给你几个靠谱的解决思路：

1. 用Mockito的超时验证（最简单） #

Mockito 2.8+版本支持在verify方法中设置超时时间，它会自动等待一段时间，直到目标方法被调用（或者超时失败），不用手动处理线程同步：

@Test
void testFooCallsExecuteWithCorrectRequest() {
    // 1. 创建Mock对象
    MyService mockService = Mockito.mock(MyService.class);
    ExecutorService testExecutor = Executors.newSingleThreadExecutor();

    // 2. 注入依赖到Foo实例（这里假设用直接赋值，也可以用@InjectMocks）
    Foo foo = new Foo();
    foo.m_service = mockService;
    foo.m_executor = testExecutor;

    // 3. 执行测试方法
    foo.foo();

    // 4. 验证：最多等待1秒，直到mockService的execute方法被传入正确参数
    // 如果MyRequest重写了equals方法，可以直接用eq匹配
    Mockito.verify(mockService, Mockito.timeout(1000)).execute(Mockito.eq(new MyRequest("bar")));
    
    // 如果没重写equals，用argThat做自定义匹配
    // Mockito.verify(mockService, Mockito.timeout(1000))
    //     .execute(Mockito.argThat(req -> "bar".equals(req.getYourFieldName())));
}

2. 用CountDownLatch手动同步线程 #

如果你的Mockito版本较低，或者需要更精细的控制，可以用CountDownLatch来让测试主线程等待异步任务完成：

@Test
void testFooCallsExecuteWithCorrectRequest() throws InterruptedException {
    MyService mockService = Mockito.mock(MyService.class);
    CountDownLatch latch = new CountDownLatch(1); // 计数器初始值为1
    ExecutorService testExecutor = Executors.newSingleThreadExecutor();

    Foo foo = new Foo();
    foo.m_service = mockService;
    // 包装Executor，在异步任务执行完成后触发计数器递减
    foo.m_executor = runnable -> {
        testExecutor.execute(() -> {
            runnable.run();
            latch.countDown(); // 任务完成，通知主线程
        });
    };

    foo.foo();

    // 等待异步任务完成，设置1秒超时避免死等
    boolean isCompleted = latch.await(1, TimeUnit.SECONDS);
    assertTrue(isCompleted, "异步任务超时未执行完成");

    // 此时异步任务已经执行完毕，可以安全验证
    Mockito.verify(mockService).execute(Mockito.argThat(req -> "bar".equals(req.getYourFieldName())));
}

3. 替换为同步执行的ExecutorService（最稳妥） #

在测试环境中，把异步的ExecutorService替换成同步执行的实现，这样所有代码都会在测试主线程中运行，彻底避免时序问题：

// 定义一个同步执行的ExecutorService，直接在当前线程运行任务
private ExecutorService syncExecutor = new ExecutorService() {
    @Override
    public void execute(Runnable command) {
        command.run(); // 同步执行，不新开线程
    }

    // 其他方法可以默认实现（测试用只需要execute方法正常工作）
    @Override public void shutdown() {}
    @Override public List<Runnable> shutdownNow() { return Collections.emptyList(); }
    @Override public boolean isShutdown() { return false; }
    @Override public boolean isTerminated() { return false; }
    @Override public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException { return false; }
    @Override public <T> Future<T> submit(Callable<T> task) { return null; }
    @Override public <T> Future<T> submit(Runnable task, T result) { return null; }
    @Override public Future<?> submit(Runnable task) { return null; }
    @Override public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException { return null; }
    @Override public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException { return null; }
    @Override public <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException { return null; }
    @Override public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException { return null; }
};

@Test
void testFooCallsExecuteWithCorrectRequest() {
    MyService mockService = Mockito.mock(MyService.class);
    Foo foo = new Foo();
    foo.m_service = mockService;
    foo.m_executor = syncExecutor; // 注入同步执行器

    foo.foo();

    // 直接验证即可，因为任务已经在主线程同步执行完毕
    Mockito.verify(mockService).execute(new MyRequest("bar"));
}

额外注意点 #

• 如果MyRequest没有正确重写equals和hashCode方法，Mockito.eq()会匹配失败，这时候一定要用argThat()做自定义参数匹配，这也是可能导致间歇性错误的隐藏原因。
• 如果用Spring等依赖注入框架，可以在测试配置中把ExecutorService的bean替换成同步版本，不用手动注入，更优雅。

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