Java并发运行JUnit测试时变量作用域优化问题咨询

现有辅助类A、集成测试类B，TestInfo类的变量原本设计为在B类的测试方法间共享，但当前采用并发模式执行测试：每个测试方法运行在独立线程中，各自持有专属的TestInfo对象，因此无法在B类中全局声明TestInfo共享对象。
当前代码存在明显冗余：测试方法中访问或修改TestInfo的属性时，每次都需要调用A.get()获取实例，再声明局部变量存储取值，所有测试方法、辅助方法都要重复编写这段逻辑。需要找到合理的变量作用域实现方式，让变量作用域覆盖当前执行方法及其内部调用的子方法，消除重复代码。
原始实现代码如下：

class TestInfo {
    int a;
    int b;
    int c;

    // 补充对应get/set方法，匹配代码中的调用逻辑
    public int getA() {return a;}
    public void setA(int a) {this.a = a;}
    public int getB() {return b;}
    public void setB(int b) {this.b = b;}
    public int getC() {return c;}
    public void setC(int c) {this.c = c;}
}

class A {
    TestInfo testinfo;

    TestInfo get() {
        return testinfo;
    }
}

class B {

    void test1() {
        int a = A.get().getA();
        int b = A.get().getB();
        int c = A.get().getC();
        A.get().setA(1);
    }

    void test2() {
        int a = A.get().getA();
        int b = A.get().getB();
        int c = A.get().getC();
        A.get().setA(2);
    }

    void test3() {
        int a = A.get().getA();
        int b = A.get().getB();
        int c = A.get().getC();
    }

    void test4() {
        int a = A.get().getA();
        int b = A.get().getB();
        int c = A.get().getC();
        A.get().setA(4);
    }

    void helper_method1() {
        int a = A.get().getA();
        int b = A.get().getB();
        int c = A.get().getC();
        A.get().setB(99);
    }

    void helper_method2() {
        int a = A.get().getA();
        int b = A.get().getB();
        int c = A.get().getC();
    }
}

根据并发测试的场景特性，有三种无冗余的实现方式，可根据项目实际情况选择：

方案1：ThreadLocal绑定线程专属实例（适配并发测试的最优方案） #

场景本身就是每个测试线程持有独立TestInfo实例，直接用JDK自带的ThreadLocal做线程级别的变量隔离，从根源上保证不同测试线程的实例不会串扰，同时彻底消除重复获取实例的代码。
首先改造A类，用ThreadLocal存储TestInfo：

class A {
    // 每个线程独立初始化自己的TestInfo实例，天然隔离
    private static final ThreadLocal<TestInfo> TEST_INFO_HOLDER = ThreadLocal.withInitial(TestInfo::new);

    public static TestInfo get() {
        return TEST_INFO_HOLDER.get();
    }

    // 测试方法执行完成后必须调用清理，避免线程池复用导致数据串扰、内存泄漏
    public static void clear() {
        TEST_INFO_HOLDER.remove();
    }
}

之后配合测试框架的生命周期钩子，在B类中绑定实例，不用每个方法重复写获取逻辑：

class B {
    private TestInfo testInfo;

    // 每个测试方法执行前，自动将当前线程的TestInfo绑定到当前测试类实例
    @BeforeEach // JUnit用这个注解，TestNG对应@BeforeMethod
    void initTestInfo() {
        this.testInfo = A.get();
    }

    // 每个测试方法执行完成后，清理线程变量
    @AfterEach // JUnit注解，TestNG对应@AfterMethod
    void cleanTestInfo() {
        A.clear();
    }

    void test1() {
        // 直接使用实例变量操作，不需要重复调用A.get()
        testInfo.setA(1);
        // 调用内部辅助方法不需要传参
        helper_method1();
    }

    void test2() {
        testInfo.setA(2);
    }

    void helper_method1() {
        // 辅助方法直接通过A.get()获取当前线程绑定的实例，不需要重复初始化
        TestInfo currentInfo = A.get();
        currentInfo.setB(99);
    }
}

这个方案的优势是不需要修改方法签名，整个线程的执行链路都可以随时拿到专属的TestInfo实例，和当前的并发测试模型完全匹配。

方案2：类内封装通用获取方法 #

如果不想引入ThreadLocal的生命周期管理，可以直接在B类中抽一个私有通用方法，统一处理TestInfo的获取逻辑，所有内部方法统一调用这个方法，减少重复代码：

class B {
    // 统一封装实例获取逻辑
    private TestInfo getCurrentInfo() {
        return A.get();
    }

    void test3() {
        TestInfo info = getCurrentInfo();
        int a = info.getA();
        int b = info.getB();
        int c = info.getC();
    }

    void helper_method2() {
        TestInfo info = getCurrentInfo();
        // 直接操作info即可
    }
}

如果多个方法都需要同时读取a、b、c三个属性，可以再抽一个专门的方法直接返回三个属性的封装对象，进一步减少重复的get调用。

方案3：调用链参数透传 #

如果希望逻辑完全显式、不依赖任何线程绑定的隐式变量，可以在测试方法入口只调用一次A.get()获取实例，之后调用所有内部辅助方法时，把这个实例作为参数透传，整个方法调用链共享同一个实例：

class B {
    void test4() {
        // 仅在入口获取一次实例
        TestInfo info = A.get();
        info.setA(4);
        // 调用辅助方法时透传实例
        helper_method1(info);
        helper_method2(info);
    }

    void helper_method1(TestInfo info) {
        int b = info.getB();
        info.setB(100);
    }

    void helper_method2(TestInfo info) {
        int c = info.getC();
    }
}

这个方案的优点是完全没有线程安全隐患，所有数据流向清晰可见，缺点是需要给所有辅助方法增加入参，适合调用链路比较简单的场景。

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