JUnit 5测试实例共享：@TestInstance.Lifecycle.PER_CLASS的线程安全实践

什么是@TestInstance.Lifecycle.PER_CLASS

在JUnit 5中，@TestInstance.Lifecycle.PER_CLASS是一个重要的注解选项，它改变了测试类实例的创建方式。默认情况下，JUnit 5为每个测试方法创建一个新的测试类实例（PER_METHOD模式），而使用PER_CLASS模式后，整个测试类只会创建一个实例，所有测试方法共享这个实例。

这种模式特别适合以下场景：

• 测试初始化成本高（如数据库连接、大型对象创建）
• 需要在多个测试方法间共享状态
• 测试类中有大量测试方法，希望减少实例创建开销

@TestInstance(Lifecycle.PER_CLASS)
public class SharedInstanceTest {
    private int counter = 0;

    @Test
    void test1() {
        counter++;
        assertEquals(1, counter);
    }

    @Test
    void test2() {
        counter++;
        assertEquals(2, counter);
    }
}

PER_CLASS模式下的线程安全问题

当测试实例在多个测试方法间共享时，线程安全问题就变得尤为重要。虽然JUnit默认情况下是单线程执行测试，但在以下场景中线程安全问题会显现：

1. 并行测试执行：使用@Execution(ExecutionMode.CONCURRENT)注解或配置junit.jupiter.execution.parallel.enabled=true时
2. 测试类字段共享：多个测试方法访问和修改同一实例变量
3. 静态字段使用：即使使用PER_CLASS，静态字段仍然是全局共享的

常见线程安全问题示例

@TestInstance(Lifecycle.PER_CLASS)
public class ThreadUnsafeTest {
    private List<String> sharedList = new ArrayList<>();

    @Test
    void addItem1() {
        sharedList.add("test1");
        assertEquals(1, sharedList.size());
    }

    @Test
    void addItem2() {
        sharedList.add("test2");
        assertEquals(1, sharedList.size()); // 可能失败
    }
}

确保线程安全的实践方案

1. 避免共享可变状态

最简单的解决方案是避免在测试类中共享可变状态。每个测试方法应该独立，不依赖其他测试方法创建的状态。

@TestInstance(Lifecycle.PER_CLASS)
public class SafeByDesignTest {
    private final Map<String, String> immutableData = Map.of(
        "key1", "value1",
        "key2", "value2"
    );

    @Test
    void testKey1() {
        assertEquals("value1", immutableData.get("key1"));
    }

    @Test
    void testKey2() {
        assertEquals("value2", immutableData.get("key2"));
    }
}

2. 使用线程安全的数据结构

当确实需要共享状态时，选择线程安全的集合和工具类：

@TestInstance(Lifecycle.PER_CLASS)
public class ThreadSafeCollectionsTest {
    private final ConcurrentMap<String, Integer> counterMap = new ConcurrentHashMap<>();

    @Test
    void incrementCounter1() {
        counterMap.compute("count", (k, v) -> v == null ? 1 : v + 1);
    }

    @Test
    void incrementCounter2() {
        counterMap.compute("count", (k, v) -> v == null ? 1 : v + 1);
    }

    @AfterAll
    void verifyCounter() {
        assertEquals(2, counterMap.get("count"));
    }
}

3. 同步访问共享资源

对于非线程安全的资源，可以使用同步机制：

@TestInstance(Lifecycle.PER_CLASS)
public class SynchronizedAccessTest {
    private final Object lock = new Object();
    private int sharedCounter = 0;

    @Test
    void incrementCounter1() {
        synchronized(lock) {
            sharedCounter++;
        }
    }

    @Test
    void incrementCounter2() {
        synchronized(lock) {
            sharedCounter++;
        }
    }
}

4. 使用ThreadLocal变量

ThreadLocal为每个线程提供独立的变量副本，非常适合测试场景：

@TestInstance(Lifecycle.PER_CLASS)
public class ThreadLocalTest {
    private final ThreadLocal<Integer> threadLocalCounter = ThreadLocal.withInitial(() -> 0);

    @Test
    void incrementCounter() {
        threadLocalCounter.set(threadLocalCounter.get() + 1);
        assertEquals(1, threadLocalCounter.get());
    }

    @Test
    void counterRemainsZero() {
        assertEquals(0, threadLocalCounter.get());
    }
}

PER_CLASS模式的最佳实践

1. 明确使用意图：只在确实需要共享状态或初始化成本高时使用PER_CLASS
2. 文档记录：在类级别注释中说明为什么使用PER_CLASS和线程安全考虑
3. 隔离测试方法：即使共享实例，测试方法也应尽可能独立
4. 清理共享状态：使用@BeforeEach/@AfterEach清理测试方法间的状态
5. 谨慎使用并行：除非充分测试，否则避免在PER_CLASS模式下并行执行

/**
 * 使用PER_CLASS因为初始化数据库连接成本高
 * 注意：测试方法会修改共享数据库，不能并行执行
 */
@TestInstance(Lifecycle.PER_CLASS)
public class DatabaseTest {
    private Connection sharedConnection;

    @BeforeAll
    void setup() throws SQLException {
        sharedConnection = DriverManager.getConnection("jdbc:h2:mem:test");
    }

    @AfterEach
    void cleanup() throws SQLException {
        sharedConnection.rollback();
    }

    @Test
    void testInsert() throws SQLException {
        // 测试插入逻辑
    }

    @Test
    void testQuery() throws SQLException {
        // 测试查询逻辑
    }

    @AfterAll
    void teardown() throws SQLException {
        sharedConnection.close();
    }
}

性能考量与取舍

PER_CLASS模式虽然可以减少实例创建开销，但也带来了线程安全的复杂性。在决定使用时，应考虑以下因素：

1. 初始化成本：如果@BeforeEach方法执行时间超过1秒，PER_CLASS可能更合适
2. 测试独立性：确保共享实例不会使测试变得脆弱
3. 并行需求：如果需要并行执行，确保线程安全措施不会抵消性能优势
4. 维护成本：复杂的线程安全代码会增加维护难度

在大多数情况下，优先选择PER_METHOD模式，只有在明确需要时才使用PER_CLASS，并充分测试其线程安全性。

总结

@TestInstance.Lifecycle.PER_CLASS是JUnit 5提供的一个强大功能，它通过共享测试实例来提高测试效率，但也引入了线程安全的考虑。合理使用线程安全技术，如不可变对象、线程安全集合、同步机制和ThreadLocal，可以确保在共享测试实例的同时保持测试的可靠性和稳定性。记住，测试代码同样需要遵循良好的设计原则和编码实践，特别是在处理共享状态时。