Spring Boot中无类变量方法的线程安全性探究：实例变量风险、竞态条件构建及代码安全性分析

架构老林

2026-4-29

嘿，我来一步步拆解你的问题，帮你理清Spring Boot里的线程安全逻辑～

关于Spring Boot中无类变量方法的线程安全性问题

1. 不使用类变量的方法一定线程安全吗？

其实不能拍胸脯说“绝对安全”，但如果方法里只用到局部变量、方法参数，或者调用的是线程安全的依赖，这类方法通常是线程安全的。原因很简单：局部变量和方法参数存在线程专属的栈内存里，每个线程都有自己的副本，完全不会被其他线程干扰。

你提到的“实例变量并非始终线程安全”完全正确——Spring默认的Bean都是单例的，单例Bean的实例变量是所有线程共享的，多个线程同时读写的话，很容易出问题。但如果你的方法根本没碰这些实例变量（就像你提供的代码那样），那风险就小很多。

2. 如何构建竞态条件？

竞态条件的本质就是多个线程同时访问同一份可变的共享资源，而且至少有一个线程在修改它，最终结果完全取决于线程执行的先后顺序。举个接地气的例子：

假设你有一个共享的计数器（比如单例Bean里的实例变量）
两个线程同时执行count++，这个操作其实拆成了“读当前值→加1→写回”三步，要是两个线程同时读到同一个初始值，最后计数器的结果就会比预期少1，这就是典型的竞态条件。

放到你的代码场景里：如果多个请求共享同一个MyUser对象（比如这个对象被缓存起来复用），同时修改它的属性，就会出现前后读取值不一致的情况。

3. 你提供的代码是否线程安全？

先看你的代码片段：

@RestController 
public class GreetingController { 
    @Autowired 
    private GreetingService greetingService; 
    @GetMapping("/hello") 
    public void greeting(@RequestBody MyUser myUser) throws Exception { 
        greetingService.getData(myUser); 
    } 
}
@Service 
public class GreetingService { 
    @Autowired 
    private DBService dBService; 
    public void getData (MyUser m ) throws InterruptedException { 
        dBService.getData(m); 
    } 
}
@Repository 
public class DBService { 
    public MyUser getData(MyUser myUser) throws InterruptedException { 
        System.out.println( "message before: " + myUser.getA() + " Thread : " +Thread.currentThread().getName()); 
        Thread.sleep(18000); 
        System.out.println( "message after " + myUser.getA() + " Thread : " +Thread.currentThread().getName()); 
        return myUser; 
    } 
}

这段代码在默认的Spring Boot场景下是线程安全的，理由如下：

Spring的@RestController、@Service、@Repository默认都是单例，但你的方法里没有修改这些Bean的实例变量（只是调用它们的方法，而这些方法也没操作共享的可变资源）。
MyUser是请求体参数，Spring MVC会为每个HTTP请求单独解析RequestBody到一个新的MyUser实例，所以每个线程操作的都是自己专属的MyUser对象，不会被其他请求的线程干扰。
DBService的getData方法只是读取MyUser的属性，没有修改它（只要你的MyUser的getA()是只读的，没有其他线程在修改这个对象）。

4. 不使用类变量前提下，如何让代码变得线程不安全？

核心思路就是让多个线程共享同一个可变对象，哪怕不用类变量也能做到，给你几个具体的例子：

方式一：复用请求参数`MyUser`对象

比如在Controller里把MyUser放到一个全局共享的缓存里，让后续请求复用同一个实例：

@RestController 
public class GreetingController { 
    @Autowired 
    private GreetingService greetingService; 
    // 全局共享的缓存（实际项目别这么写，只是演示）
    private static final List<MyUser> SHARED_USER_LIST = new ArrayList<>();

    @GetMapping("/hello") 
    public void greeting(@RequestBody MyUser myUser) throws Exception { 
        MyUser targetUser;
        // 如果缓存为空，就把当前请求的MyUser放进去；否则复用缓存里的对象
        if (SHARED_USER_LIST.isEmpty()) {
            targetUser = myUser;
            SHARED_USER_LIST.add(targetUser);
        } else {
            targetUser = SHARED_USER_LIST.get(0);
        }
        // 启动一个线程，在sleep期间修改共享的MyUser的属性
        new Thread(() -> {
            try {
                Thread.sleep(9000);
                targetUser.setA("modified by another thread");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        greetingService.getData(targetUser);
    } 
}

这时如果两个请求同时进来，它们会操作同一个MyUser对象：第一个请求的getData在sleep的18秒里，另一个线程修改了targetUser.getA()，等sleep结束后，输出的message after就会和message before不一样，竞态条件就出现了。

方式二：让`MyUser`本身是共享的可变对象

比如把MyUser声明为单例Bean（虽然不符合请求体的常规用法，但用来演示）：

@Component
public class MyUser {
    private String a;
    // getter和setter
}

然后在Controller里直接注入这个单例的MyUser，而不是用请求体参数：

@RestController 
public class GreetingController { 
    @Autowired 
    private GreetingService greetingService; 
    @Autowired
    private MyUser sharedMyUser; // 单例，所有线程共享

    @GetMapping("/hello") 
    public void greeting() throws Exception { 
        // 每个请求都修改同一个共享的MyUser
        sharedMyUser.setA("request from " + Thread.currentThread().getName());
        greetingService.getData(sharedMyUser);
    } 
}

这样多个请求同时进来，就会同时修改同一个MyUser的属性，导致DBService里前后输出的a值不一致。

方式三：调用非线程安全的共享依赖

比如你的DBService里调用了一个单例的非线程安全服务，比如未同步的日期工具类：

@Service
public class NonThreadSafeDateService {
    // SimpleDateFormat是非线程安全的
    private final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

    public String formatDate(Date date) {
        return sdf.format(date);
    }
}

@Repository 
public class DBService { 
    @Autowired
    private NonThreadSafeDateService dateService; // 单例，所有线程共享

    public MyUser getData(MyUser myUser) throws InterruptedException { 
        // 多个线程同时调用这个非线程安全的方法，会出现格式化错误
        String dateStr = dateService.formatDate(new Date());
        System.out.println( "message before: " + myUser.getA() + " date: " + dateStr + " Thread : " +Thread.currentThread().getName());
        Thread.sleep(18000);
        System.out.println( "message after " + myUser.getA() + " date: " + dateStr + " Thread : " +Thread.currentThread().getName());
        return myUser; 
    } 
}

这里DBService本身没有类变量，但因为依赖的NonThreadSafeDateService是单例且非线程安全的，多个线程同时调用formatDate就会出现异常或者错误的日期格式，这也算线程不安全的情况。

总结一下：线程安全的核心是对共享可变资源的访问控制，不管是不是类变量，只要多个线程能同时读写同一个可变对象，就可能出现线程不安全的问题。

内容的提问来源于stack exchange，提问作者Pale Blue Dot

Spring Boot中无类变量方法的线程安全性探究：实例变量风险、竞态条件构建及代码安全性分析

1. 不使用类变量的方法一定线程安全吗？ #

2. 如何构建竞态条件？ #

3. 你提供的代码是否线程安全？ #

4. 不使用类变量前提下，如何让代码变得线程不安全？ #

方式一：复用请求参数MyUser对象 #

方式二：让MyUser本身是共享的可变对象 #

方式三：调用非线程安全的共享依赖 #