当前位置：首页 > news >正文

Spring 单例 Bean 的多线程并发问题详解

news 2025/10/6 13:46:04

在 Spring 框架中，单例（Singleton）Bean 是最常见的 Bean 作用域类型。
然而，很多初学者在实际开发中会忽略一个关键问题：单例 Bean 在多线程场景下可能会产生并发安全问题。
本文将通过一个示例带你深入理解这一点。

一、什么是单例 Bean？

在 Spring 中，Bean 是由容器（ApplicationContext）管理的对象。
当我们定义一个 Bean 而不指定作用域时，Spring 默认将其设置为 单例模式（singleton）。

这意味着：

在整个 Spring 容器中，该 Bean 只会被创建一次，并被所有调用方共享同一个实例。

例如：

@Component
public class UserService {
}

当我们获取两次 Bean 时：

ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
UserService u1 = context.getBean(UserService.class);
UserService u2 = context.getBean(UserService.class);
System.out.println(u1 == u2); // true

输出结果为 true，说明容器中只有一个对象实例。

二、单例 Bean 在多线程中的风险

单例 Bean 在容器中是全局唯一的，这本身没问题。
但如果这个 Bean 内部存在可变的成员变量（即有状态的 Bean），就会在多线程访问时出现并发问题。

因为：
所有线程都会共享这个 Bean 的同一块内存区域，如果其中的字段被修改，就可能发生 数据竞争（race condition）。

三、问题示例：计数器并发异常

来看一个具体的例子👇

1️⃣ 单例 Bean 类

import org.springframework.stereotype.Service;@Service
public class CounterService {private int count = 0; // 可变状态，存在竞争风险public void increment() {try {Thread.sleep(10); // 模拟耗时操作} catch (InterruptedException e) {e.printStackTrace();}count++;}public int getCount() {return count;}
}

这里的 count 字段会被多个线程同时修改。

2️⃣ 测试类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;@Component
public class CounterTest implements CommandLineRunner {@Autowiredprivate CounterService counterService;@Overridepublic void run(String... args) throws Exception {for (int i = 0; i < 100; i++) {new Thread(() -> counterService.increment()).start();}Thread.sleep(2000);System.out.println("最终计数结果：" + counterService.getCount());}
}

3️⃣ 运行结果

理论上，100 个线程各自执行一次 increment()，结果应该是 100。
但实际输出可能是：

最终计数结果：95

或

最终计数结果：98

不同次数运行结果不同，这正是并发导致的丢失更新问题。

四、问题原因分析

count++ 不是一个原子操作，执行时实际上分为三步：

读取变量 count；
将其加 1；
把结果写回内存。

当多个线程同时执行时，就可能出现这样的情况：

线程 A 读取到 count = 10
线程 B 也读取到 count = 10
A 和 B 分别执行加 1 操作
最终写回时，结果仍然是 11，而不是 12

这就是典型的数据竞争。

五、解决方案

✅ 方案一：让 Bean “无状态化”

最根本的解决办法是 不要在单例 Bean 中保存可变成员变量。
让它成为一个“无状态”的服务类：

@Service
public class CounterService {public int increment(int count) {return count + 1;}
}

每个线程各自维护数据，不共享状态，就不会出现并发问题。

✅ 方案二：使用线程安全类

如果确实需要共享状态，可以使用 AtomicInteger 等并发安全的工具类：

import java.util.concurrent.atomic.AtomicInteger;
import org.springframework.stereotype.Service;@Service
public class SafeCounterService {private final AtomicInteger count = new AtomicInteger(0);public void increment() {count.incrementAndGet();}public int getCount() {return count.get();}
}

这样无论多少线程访问，最终结果都是正确的。

✅ 方案三：使用同步锁（synchronized）

对于更复杂的逻辑，可以使用同步锁：

@Service
public class SyncCounterService {private int count = 0;public synchronized void increment() {count++;}public synchronized int getCount() {return count;}
}

虽然能保证线程安全，但会带来一定性能损耗。

六、总结

项目	说明
问题根源	单例 Bean 在容器中只有一个实例，被多个线程共享
风险点	Bean 内部存在可变成员变量
表现	出现数据竞争、丢失更新、状态混乱
最佳实践	保持无状态，或使用线程安全工具类