prototype 注入到 singleton 里，prototype是否还是线程安全的

"如果 prototype Bean 内部没有共享状态，自身是线程安全的。但 Spring 容器对 prototype 的多例行为有'陷阱'，可能导致实际使用中不安全。"

展开讲：

prototype 注入到 singleton 里的线程安全分析

一、prototype Bean 自身的线程安全性

1.1 prototype 本身是"独立实例"（这个是安全的）

@Service@Scope("prototype")public class ShoppingCart { private List<Item> items = new ArrayList<>(); public void addItem(Item item) { items.add(item); // 操作的是自己的成员变量 }}

为什么自身是线程安全的？

**所以 prototype Bean 本身是线程安全的，前提是你每次都拿到了不同的实例。

1.2 但这里有"陷阱"——老哥 7+ 年必须知道

如果不加 proxyMode，singleton 里的 prototype 不是"真多例"：

@Service // singletonpublic class OrderService { @Autowired private ShoppingCart cart; // ⚠️ 看着像 prototype}

实际行为：

• OrderService 是单例，整个应用只有 1 个
• cart 在 OrderService 创建时注入一次
• cart 永远是同一个 ShoppingCart 实例！
• 1000 个请求都共享同一个 cart → 多线程同时改 cart.items → 线程不安全！

二、3 种场景的线程安全分析

场景 1：纯 prototype（不注入到 singleton，直接 getBean）

ApplicationContext ctx = ...;ShoppingCart cart1 = ctx.getBean(ShoppingCart.class); // 实例 1ShoppingCart cart2 = ctx.getBean(ShoppingCart.class); // 实例 2（不同对象）

线程安全：✅ 是

• 每次 getBean 都返回新实例
• 多个线程拿到不同实例
• 互不干扰

场景 2：prototype 注入到 singleton（不加 proxyMode）

@Service // singletonpublic class OrderService { @Autowired private ShoppingCart cart; // 注入时拿到一次}

线程安全：❌ 否

• 整个应用 1 个 OrderService
• 整个应用 1 个 cart（注入时定下来）
• 多线程共享同一 cart → 不安全

场景 3：prototype + proxyMode / @Lazy（真正多例）

@Service@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE, proxyMode = ScopedProxyMode.TARGET_CLASS)public class ShoppingCart { ... }@Servicepublic class OrderService { @Autowired private ShoppingCart cart; // 代理对象}

线程安全：✅ 是

• 注入的是代理对象
• 每次调用 cart 方法时，代理内部创建一个新的 ShoppingCart
• 1000 个请求 → 1000 个不同 ShoppingCart → 互不干扰

三、Spring 多例的 4 个"坑"（老哥面试加分）

坑 1：注入时拿到一次（最常踩）

@Servicepublic class A { @Autowired private PrototypeBean b; // ⚠️ 整个 A 共享同一个 b}

解决： proxyMode = TARGET_CLASS 或 @Lazy

坑 2：@Async 注解的方法内 prototype 失效

@Service@Scope("prototype")public class TaskRunner { ... }@Servicepublic class TaskService { @Autowired private TaskRunner runner; @Async // 异步调用 public void run() { // 这里 runner 是多少个？看注入方式 }}

坑：

• 如果 @Autowired 直接注入，runner 永远同一个
• 必须用 ObjectProvider<TaskRunner> 每次 .getObject() 才拿到新实例

坑 3：prototype 在 @Configuration 里 @Bean 不会自动多例

@Configurationpublic class AppConfig { @Bean @Scope("prototype") public ShoppingCart cart() { return new ShoppingCart(); }}

坑：

• 这种写法是真的多例（每次 getBean 都新建）
• 但调用 cart() 方法本身只返回同一个对象（因为 Spring 拦截了 @Bean 方法）
• 实际多例要靠其他 Bean 注入或 getBean 触发

坑 4：prototype Bean 的销毁不归 Spring 管

@PreDestroy // ⚠️ prototype Bean 上加这个不会生效public void cleanup() { // 永远不会调用}

解决：

• 实现 DisposableBean 接口
• 用 BeanPostProcessor 手动管理

四、面试官追问应对

追问：prototype 注入到 singleton 里，prototype 还线程安全吗？

"分情况看：

如果用 proxyMode / @Lazy 真正多例：✅ 线程安全（每个线程拿到不同实例）。

如果直接 @Autowired 不加处理：❌ 不安全（整个应用共享同一个 prototype 实例）。

核心坑：singleton Bean 创建时 prototype 注入一次，多线程共享。

追问 2：怎么判断当前 Bean 是不是 prototype？

// 运行时判断if (ctx.containsBean("xxx") && ctx.isPrototype("xxx")) { // 是 prototype}

追问 3：怎么让 singleton 注入 prototype 真的多例？

"3 种方法：

1.@Scope + proxyMode = TARGET_CLASS（最推荐）

2.@Lazy（延迟加载，代理对象）

3.ObjectProvider<PrototypeBean> + .getObject()（最灵活）"

追问 4：ObjectProvider 怎么用？

@Servicepublic class OrderService { @Autowired private ObjectProvider<ShoppingCart> cartProvider; // 不直接注入 public void checkout() { ShoppingCart cart = cartProvider.getObject(); // 每次调用拿到新实例 cart.addItem(...); }}

ObjectProvider 优点：

• 显式控制获取时机
• 不用加 @Scope / @Lazy / proxyMode
• 项目里推荐用这个（最清晰）

六、面试答法模板

"3 句话讲清楚 prototype 线程安全：

1.prototype 本身是独立的（每个实例不共享成员变量），所以自身线程安全。

2.但注入到 singleton Bean 里时，不加 proxyMode / @Lazy 会变成'假多例'（整个应用共享同一实例），多线程并发改这个共享实例就线程不安全。

3.**正确做法：proxyMode = TARGET_CLASS / @Lazy / ObjectProvider，**保证每次调用拿到新实例。

我做的 MOVA 报表生成器就是这个套路，proxyMode 让 100 个并发任务互不干扰。"

七、一句话总结

"prototype 自身线程安全，但注入到 singleton 不加 proxyMode 会变成'假多例'，整个应用共享一个 prototype 实例，反而不安全。"

《prototype 注入到 singleton 里，prototype是否还是线程安全的》 是转载文章，点击查看原文。