Spring 容器中 单例Bean 的线程安全分析

问题：Spring容器中的单例bean是线程安全的吗？

结论：不是线程安全的

Spring 容器本身未提供 Bean 的线程安全策略，因此 Spring 容器中的 Bean 默认不具备线程安全特性，具体需结合 Bean 的作用域（Scope）分析。

Spring Bean 作用域（Scope）类型

1. singleton：单例（默认作用域）
2. prototype：原型（每次请求创建新实例）
3. request：请求作用域（每次 HTTP 请求创建新实例，适用于 Web 环境）
4. session：会话作用域（同一会话共享实例）
5. global-session：全局会话作用域（所有会话共享实例）

线程安全分析：原型 Bean 与单例 Bean

原型 Bean（prototype）

• 特性：每次请求创建新实例，线程间无共享 Bean。
• 结论：天然线程安全，无需额外处理。

单例 Bean（singleton）

• 特性：所有线程共享同一实例，可能存在资源竞争。
• 线程安全条件：
  • 无状态 Bean：不存储成员变量状态（如仅包含方法逻辑），线程安全。
  • 有状态 Bean：存储成员变量状态（如成员变量赋值操作），需手动保证线程安全。

为什么 Spring 的 Controller、Service、Dao 默认是线程安全的？

• 本质原因：这些组件通常是无状态的，仅包含方法逻辑，不存储线程间共享的状态。
• 技术支撑：
  • 局部变量存储于线程私有栈（JVM 虚拟机栈），线程间不共享。
  • 方法调用的参数和临时变量均为线程私有，无竞争风险。
  • 参考：《深入理解 JVM 虚拟机》2.2.2 节、《Java 并发编程实战》3.2.2 节。

实战验证：单例 Bean 的线程安全问题

案例 1：单例模式下的有状态 Bean（非线程安全）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

@RestController
public class TestController {
    private int var = 0; // 成员变量（有状态）

    @GetMapping("/test_var")
    public String test() {
        System.out.println("普通变量var:" + (++var));
        return "var: " + var;
    }
}

• 请求结果：

  1 2 3

  普通变量var:1 （第一次请求） 普通变量var:2 （第二次请求） 普通变量var:3 （第三次请求）

  结论：成员变量被多线程共享，导致状态不一致，非线程安全。

案例 2：使用@Scope("prototype")的原型 Bean

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

@RestController
@Scope("prototype") // 改为原型作用域
public class TestController {
    private int var = 0;

    @GetMapping("/test_var")
    public String test() {
        System.out.println("普通变量var:" + (++var));
        return "var: " + var;
    }
}

• 请求结果：

  1 2 3

  普通变量var:1 （每次请求均为新实例，结果独立） 普通变量var:1 普通变量var:1

  结论：原型 Bean 为每个请求创建独立实例，解决成员变量共享问题。

特殊场景：静态变量与依赖注入 Bean 的线程安全

场景 1：静态变量（线程不安全）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

@RestController
@Scope("prototype")
public class TestController {
    private static int staticVar = 0; // 静态变量（类级共享）

    @GetMapping("/test_var")
    public String test() {
        System.out.println("静态变量staticVar:" + (++staticVar));
        return "staticVar: " + staticVar;
    }
}

• 请求结果：

  1 2 3

  静态变量staticVar:1 （累加，与作用域无关） 静态变量staticVar:2 静态变量staticVar:3

  结论：静态变量属于类级资源，无论作用域如何，均为全局共享，线程不安全。

场景 2：依赖注入的单例 Bean（线程不安全）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

@RestController
public class TestController {
    @Autowired
    private User user; // 注入单例User Bean

    @GetMapping("/test_user")
    public String test() {
        user.setAge(user.getAge() + 1);
        return "User age: " + user.getAge();
    }
}

@Configuration
public class MyConfig {
    @Bean
    public User user() { // 默认为单例
        return new User();
    }
}

• 请求结果：

  1 2	User age: 1 （第一次请求） User age: 2 （第二次请求）

  结论：依赖注入的单例 Bean 被多线程共享，需配合@Scope("prototype")或线程安全设计。

线程安全解决方案总结

1. 优先使用无状态设计：避免在 Bean 中定义成员变量，仅通过方法参数或局部变量处理逻辑。
2. 原型作用域（prototype）：对有状态 Bean，使用@Scope("prototype")为每个请求创建独立实例。
3. ThreadLocal：封装需要线程隔离的变量，确保线程私有。
4. 静态变量慎用：静态变量为类级共享，需全局同步控制（不推荐）。
5. 依赖注入 Bean 的作用域匹配：确保注入的 Bean 与当前 Bean 作用域一致（如原型 Bean 注入原型 Bean）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 推荐：使用ThreadLocal实现线程隔离
@RestController
public class TestController {
    private ThreadLocal<Integer> tl = new ThreadLocal<>();

    @GetMapping("/test_tl")
    public String test() {
        tl.set(tl.get() != null ? tl.get() + 1 : 1);
        return "ThreadLocal value: " + tl.get();
    }
}

总结

• 默认单例 Bean 非线程安全：Spring 默认使用单例模式，无状态 Bean 可视为线程安全，有状态 Bean 需额外处理。
• 作用域选择：
  • 无状态 Bean：使用单例（性能最优）。
  • 有状态 Bean：使用原型或结合 ThreadLocal。
• 核心原则：减少共享状态，优先通过设计规避线程安全问题，而非依赖框架兜底。