如何无需手动编写所有并发调用和线程池创建代码，对线程安全的类方法进行多线程并发单元测试？

兄弟，你这个需求太懂行啦——手动写线程池、管理并发调用真的又繁琐又容易出错，完全没必要自己造轮子！给你几个实用的思路，都是不用手动撸大量线程代码就能搞定并发单元测试的方法：

• 用JUnit 5自带的并行测试功能
  JUnit 5原生支持并行测试，只需要简单配置就能让框架帮你管理线程池、并发执行测试。
  第一步，在src/test/resources/junit-platform.properties里加配置：

  junit.jupiter.execution.parallel.enabled = true
  junit.jupiter.execution.parallel.mode.default = concurrent
  

  然后写测试类的时候，给测试方法或者类加上@Execution(ExecutionMode.CONCURRENT)注解，JUnit就会自动并发执行这个测试的多个实例。比如：

  import org.junit.jupiter.api.Test;
  import org.junit.jupiter.api.parallel.Execution;
  import org.junit.jupiter.api.parallel.ExecutionMode;
  import static org.junit.jupiter.api.Assertions.*;
  
  @Execution(ExecutionMode.CONCURRENT)
  public class ThreadSafeClassTest {
      // 用静态实例保证所有测试线程共享同一个对象
      private static final ThreadSafeClass target = new ThreadSafeClass();
  
      @Test
      void testConcurrentStateUpdate() {
          target.updateState(); // 调用你的线程安全方法
          // 这里可以做单次调用的基础断言，或者最后统一验证全局不变量
      }
  
      // 所有并发测试跑完后，验证核心不变量
      @Test
      void verifyInvariantAfterAllCalls() {
          assertTrue(target.isStateValid()); // 比如检查状态是否符合预期约束
      }
  }
  

  这种方式完全不用自己写线程创建、池管理的代码，JUnit全帮你搞定。

• 借助AssertJ的并发简化工具
  AssertJ（一个常用的断言库）提供了简洁的并发任务处理API，结合CompletableFuture可以轻松发起大量并发调用，还能统一等待任务完成并验证结果。比如：

  import org.assertj.core.api.Assertions;
  import org.junit.jupiter.api.Test;
  import java.util.concurrent.CompletableFuture;
  import java.util.stream.IntStream;
  
  public class ThreadSafeClassTest {
      private final ThreadSafeClass target = new ThreadSafeClass();
  
      @Test
      void testConcurrentUpdatesPreserveInvariant() {
          // 发起100个并发调用，底层用默认线程池，不用手动创建
          var futures = IntStream.range(0, 100)
                  .mapToObj(i -> CompletableFuture.runAsync(target::updateState))
                  .toList();
          
          // 等待所有并发任务完成，同时验证没有任务失败
          Assertions.assertThat(futures).allSucceed();
          
          // 验证核心不变量，比如状态的最终值符合预期，或者始终处于合法状态
          Assertions.assertThat(target.getCurrentState())
                  .isGreaterThanOrEqualTo(0)
                  .isEqualTo(100); // 假设每次调用状态+1，100次后应该是100
      }
  }
  

  这里CompletableFuture.runAsync会自动用JDK的ForkJoinPool，不用你手动管理线程池，AssertJ的allSucceed()帮你简化了等待和异常检查的逻辑。

• 用TestNG的并发测试注解
  TestNG对并发测试的支持非常直观，只需要在测试方法上配置调用次数和线程池大小，框架就会自动帮你并发执行。比如：

  import org.testng.annotations.Test;
  import static org.testng.Assert.*;
  
  public class ThreadSafeClassTest {
      private ThreadSafeClass target = new ThreadSafeClass();
  
      // 用10个线程，重复调用这个方法100次
      @Test(invocationCount = 100, threadPoolSize = 10)
      void testConcurrentStateUpdate() {
          target.updateState();
      }
  
      // 依赖上面的测试，确保所有并发调用完成后再验证不变量
      @Test(dependsOnMethods = "testConcurrentStateUpdate")
      void verifyFinalStateInvariant() {
          assertTrue(target.checkInvariant());
      }
  }
  

  这种方式连配置文件都不用改，直接在注解里指定并发参数就行，非常省心。

最后提个小建议：并发问题很多是概率性的，所以最好让测试重复执行多次，或者设置较高的并发数，提高触发潜在问题的概率。另外，验证的时候一定要盯着你的核心不变量（比如状态不能为负、最终值符合业务逻辑、对象始终处于合法状态），而不是只测单次调用的结果。

备注：内容来源于stack exchange，提问作者Jim