Spring单例模式与多线程安全：深入理解容器级单例的线程安全机制
深入解析Spring单例模式的实现原理，探讨多线程环境下的变量安全问题。从Spring容器的单例管理到线程安全的最佳实践，提供完整的解决方案和代码示例，帮助开发者正确处理Spring应用中的并发问题。
Gerrad Zhang
武汉，中国
2 min read
🤔 问题背景与技术演进
我们要解决什么问题？
在Spring框架的使用过程中，开发者经常会遇到这样的困惑：
- Spring说Bean是单例的：所有注入的地方都是同一个对象
- 多线程访问问题：多个线程同时访问单例Bean中的变量会发生什么？
- 变量安全性：如何保证
int a = 1这样的变量在不同线程中的修改不被干扰？ - 性能与安全平衡：如何在保证线程安全的同时维持良好的性能？
// 这是一个典型的Spring单例Bean
@Service
public class CounterService {
private int counter = 0; // 这个变量安全吗？
public void increment() {
counter++; // 多线程环境下会发生什么？
}
public int getCounter() {
return counter; // 能获取到期望的值吗？
}
}
没有这个技术时是怎么做的？
在Spring框架出现之前，Java开发者需要手动管理对象的生命周期和单例模式：
1. 传统单例模式的实现
// 饿汉式单例 - 线程安全但浪费内存
public class EagerSingleton {
private static final EagerSingleton INSTANCE = new EagerSingleton();
private EagerSingleton() {}
public static EagerSingleton getInstance() {
return INSTANCE;
}
}
// 懒汉式单例 - 需要手动处理线程安全
public class LazySingleton {
private static volatile LazySingleton instance;
private LazySingleton() {}
public static LazySingleton getInstance() {
if (instance == null) {
synchronized (LazySingleton.class) {
if (instance == null) {
instance = new LazySingleton();
}
}
}
return instance;
}
}
2. 手动依赖管理
// 需要手动创建和管理对象依赖关系
public class ManualDependencyManagement {
private UserService userService;
private OrderService orderService;
public ManualDependencyManagement() {
// 手动创建依赖
this.userService = new UserService();
this.orderService = new OrderService(userService);
}
// 需要手动管理生命周期
public void cleanup() {
userService.cleanup();
orderService.cleanup();
}
}
3. 线程安全的手动处理
// 每个类都需要自己处理线程安全
public class ThreadSafeCounter {
private int counter = 0;
private final Object lock = new Object();
public void increment() {
synchronized (lock) {
counter++;
}
}
public int getCounter() {
synchronized (lock) {
return counter;
}
}
}
技术演进的历史脉络
EJB时代 (1998-2004)：企业级Bean容器
- 提供了容器管理的单例概念
- 但配置复杂，性能较差
- 需要大量的XML配置和接口实现
Spring框架诞生 (2003)：轻量级容器革命
- 引入了IoC（控制反转）容器
- 简化了单例Bean的管理
- 提供了声明式的依赖注入
Spring 2.0+ (2006)：注解驱动开发
- 引入
@Component、@Service等注解 - 简化了Bean的声明和配置
- 默认单例作用域成为标准
Spring Boot时代 (2014)：约定优于配置
- 自动配置大量单例Bean
- 开发者更少关注Bean的生命周期
- 但线程安全问题变得更加隐蔽
🎯 核心概念与原理
Spring单例模式的本质
Spring的单例模式与传统的Singleton设计模式有本质区别：
/**
* Spring容器级单例的实现原理
*/
public class SpringSingletonPrinciple {
/**
* Spring容器的简化实现
*/
public class SimplifiedApplicationContext {
// 单例Bean缓存池 - Spring单例的核心
private final ConcurrentHashMap<String, Object> singletonObjects = new ConcurrentHashMap<>();
private final Map<String, BeanDefinition> beanDefinitions = new HashMap<>();
/**
* 获取Bean实例 - 容器级单例的核心逻辑
*/
public Object getBean(String beanName) {
// 1. 先从单例缓存中查找
Object singleton = singletonObjects.get(beanName);
if (singleton == null) {
synchronized (this.singletonObjects) {
// 2. 双重检查锁定
singleton = singletonObjects.get(beanName);
if (singleton == null) {
// 3. 创建新的Bean实例
singleton = createBean(beanName);
// 4. 放入单例缓存
singletonObjects.put(beanName, singleton);
}
}
}
return singleton;
}
private Object createBean(String beanName) {
BeanDefinition definition = beanDefinitions.get(beanName);
try {
// 简化的Bean创建逻辑
Object instance = definition.getBeanClass().newInstance();
// 依赖注入
injectDependencies(instance);
return instance;
} catch (Exception e) {
throw new RuntimeException("创建Bean失败: " + beanName, e);
}
}
private void injectDependencies(Object instance) {
// 简化的依赖注入逻辑
// 实际Spring会处理@Autowired、@Resource等注解
}
}
/**
* Bean定义信息
*/
static class BeanDefinition {
private Class<?> beanClass;
private String scope = "singleton"; // 默认单例
// getters and setters
public Class<?> getBeanClass() { return beanClass; }
public void setBeanClass(Class<?> beanClass) { this.beanClass = beanClass; }
public String getScope() { return scope; }
public void setScope(String scope) { this.scope = scope; }
}
}
Spring单例的特点
1. 容器级别的单例
@Component
public class UserService {
// 在整个Spring容器中只有一个实例
// 但在不同的JVM或不同的ApplicationContext中可以有多个实例
}
/**
* 验证Spring单例特性
*/
@RestController
public class SingletonTestController {
@Autowired
private UserService userService1;
@Autowired
private UserService userService2;
@GetMapping("/test-singleton")
public String testSingleton() {
// 验证是否为同一个实例
boolean isSame = (userService1 == userService2);
return "是否为同一个实例: " + isSame; // 输出: true
}
}
2. 线程共享特性
@Service
public class SharedStateService {
private int requestCount = 0; // 所有线程共享这个变量
private String lastUser = ""; // 所有线程共享这个变量
public void processRequest(String username) {
// 多个线程同时执行这个方法时
// 都在操作同一个requestCount和lastUser变量
requestCount++; // 线程不安全！
lastUser = username; // 线程不安全！
}
}
🔧 多线程安全问题分析
问题场景演示
/**
* Spring单例Bean中的线程安全问题演示
*/
@Service
public class UnsafeCounterService {
private int counter = 0; // 实例变量 - 多线程共享
/**
* 线程不安全的递增操作
*/
public void increment() {
counter++; // 这不是原子操作！
/*
* counter++ 实际包含三个步骤：
* 1. 读取counter的当前值 (read)
* 2. 将值加1 (modify)
* 3. 将结果写回counter (write)
*
* 多线程执行时可能的交错情况：
*
* 时间 | 线程A | 线程B | counter值
* -----|-------|-------|----------
* T1 | 读取0 | | 0
* T2 | | 读取0 | 0
* T3 | 计算1 | | 0
* T4 | | 计算1 | 0
* T5 | 写入1 | | 1
* T6 | | 写入1 | 1
*
* 结果：期望值是2，实际值是1
*/
}
public int getCounter() {
return counter; // 读取操作也可能不一致
}
/**
* 演示更复杂的线程安全问题
*/
private String lastOperation = "";
private long lastTimestamp = 0;
public void recordOperation(String operation) {
// 多个字段的更新不是原子的
lastOperation = operation; // 步骤1
// 如果在这里发生线程切换...
lastTimestamp = System.currentTimeMillis(); // 步骤2
// 其他线程可能看到不一致的状态：
// lastOperation是新值，但lastTimestamp还是旧值
}
}
并发测试验证
/**
* 线程安全问题的测试验证
*/
@Component
public class ThreadSafetyTester {
@Autowired
private UnsafeCounterService counterService;
/**
* 并发测试方法
*/
public void testConcurrency() throws InterruptedException {
int threadCount = 100;
int incrementsPerThread = 1000;
CountDownLatch latch = new CountDownLatch(threadCount);
// 创建多个线程同时执行increment操作
for (int i = 0; i < threadCount; i++) {
new Thread(() -> {
try {
for (int j = 0; j < incrementsPerThread; j++) {
counterService.increment();
}
} finally {
latch.countDown();
}
}).start();
}
// 等待所有线程完成
latch.await();
int expectedValue = threadCount * incrementsPerThread; // 期望值: 100,000
int actualValue = counterService.getCounter(); // 实际值: 通常小于100,000
System.out.printf("期望值: %d, 实际值: %d, 数据丢失: %d%n",
expectedValue, actualValue, expectedValue - actualValue);
}
}
🛠️ 线程安全解决方案
方案一：synchronized关键字
/**
* 使用synchronized确保线程安全
*/
@Service
public class SynchronizedCounterService {
private int counter = 0;
/**
* 方法级synchronized
*/
public synchronized void increment() {
counter++; // 现在是线程安全的
}
public synchronized int getCounter() {
return counter;
}
/**
* 代码块级synchronized - 更细粒度的控制
*/
private final Object lock = new Object();
public void incrementWithBlock() {
synchronized (lock) {
counter++;
}
}
/**
* 不同锁对象的使用
*/
private int readCount = 0;
private int writeCount = 0;
private final Object readLock = new Object();
private final Object writeLock = new Object();
public void incrementReadCount() {
synchronized (readLock) {
readCount++;
}
}
public void incrementWriteCount() {
synchronized (writeLock) {
writeCount++;
}
}
}
synchronized的优缺点分析：
✅ 优点：
- 简单易用，JVM保证原子性
- 自动释放锁，避免死锁
- 可见性和有序性都有保障
❌ 缺点：
- 性能开销较大
- 阻塞式锁，可能导致线程饥饿
- 无法中断等待中的线程
方案二：原子类 (推荐)
/**
* 使用原子类实现高性能线程安全
*/
@Service
public class AtomicCounterService {
// 原子整数
private final AtomicInteger counter = new AtomicInteger(0);
// 原子长整数
private final AtomicLong totalRequests = new AtomicLong(0);
// 原子引用
private final AtomicReference<String> lastUser = new AtomicReference<>("");
/**
* 原子递增操作
*/
public int increment() {
return counter.incrementAndGet(); // 原子操作，高性能
}
public int getCounter() {
return counter.get();
}
/**
* 原子的比较并交换操作
*/
public boolean updateLastUser(String expectedUser, String newUser) {
return lastUser.compareAndSet(expectedUser, newUser);
}
/**
* 复杂的原子操作
*/
public void recordRequest(String username) {
// 原子递增请求计数
totalRequests.incrementAndGet();
// 原子更新最后用户
lastUser.set(username);
}
/**
* 自定义原子操作
*/
public int addAndGetSquare(int delta) {
return counter.updateAndGet(current -> {
int newValue = current + delta;
return newValue * newValue; // 返回平方值
});
}
/**
* 原子操作的性能测试
*/
public void performanceTest() throws InterruptedException {
int threadCount = 100;
int operationsPerThread = 10000;
CountDownLatch latch = new CountDownLatch(threadCount);
long startTime = System.currentTimeMillis();
for (int i = 0; i < threadCount; i++) {
new Thread(() -> {
try {
for (int j = 0; j < operationsPerThread; j++) {
counter.incrementAndGet();
}
} finally {
latch.countDown();
}
}).start();
}
latch.await();
long endTime = System.currentTimeMillis();
System.out.printf("原子操作测试 - 耗时: %d ms, 最终值: %d%n",
endTime - startTime, counter.get());
}
}
方案三：ThreadLocal (线程隔离)
/**
* 使用ThreadLocal实现线程隔离
*/
@Service
public class ThreadLocalService {
// 每个线程都有自己的counter副本
private final ThreadLocal<Integer> threadLocalCounter = new ThreadLocal<Integer>() {
@Override
protected Integer initialValue() {
return 0; // 初始值
}
};
// 使用ThreadLocal存储用户上下文
private final ThreadLocal<UserContext> userContextHolder = new ThreadLocal<>();
/**
* 线程安全的递增操作 - 每个线程独立计数
*/
public void increment() {
Integer current = threadLocalCounter.get();
threadLocalCounter.set(current + 1);
}
public int getCounter() {
return threadLocalCounter.get();
}
/**
* 用户上下文管理
*/
public void setUserContext(String userId, String username) {
UserContext context = new UserContext(userId, username);
userContextHolder.set(context);
}
public UserContext getCurrentUserContext() {
return userContextHolder.get();
}
/**
* 重要：清理ThreadLocal防止内存泄漏
*/
public void clearContext() {
threadLocalCounter.remove();
userContextHolder.remove();
}
/**
* 用户上下文类
*/
static class UserContext {
private final String userId;
private final String username;
public UserContext(String userId, String username) {
this.userId = userId;
this.username = username;
}
// getters
public String getUserId() { return userId; }
public String getUsername() { return username; }
}
/**
* Web请求中的ThreadLocal使用示例
*/
@Component
public static class UserContextFilter implements Filter {
@Autowired
private ThreadLocalService threadLocalService;
@Override
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
try {
// 从请求中提取用户信息
String userId = request.getParameter("userId");
String username = request.getParameter("username");
// 设置到ThreadLocal中
if (userId != null && username != null) {
threadLocalService.setUserContext(userId, username);
}
// 继续处理请求
chain.doFilter(request, response);
} finally {
// 请求结束后清理ThreadLocal
threadLocalService.clearContext();
}
}
}
}
方案四：volatile关键字 (有限场景)
/**
* volatile的正确使用场景
*/
@Service
public class VolatileService {
// volatile适用于简单的标志位
private volatile boolean initialized = false;
private volatile boolean shutdown = false;
// volatile不适用于复合操作
private volatile int counter = 0; // 不安全！counter++不是原子操作
/**
* 正确使用volatile的场景：状态标志
*/
public void initialize() {
// 执行初始化逻辑
performInitialization();
// 设置标志位 - 对所有线程立即可见
initialized = true;
}
public boolean isInitialized() {
return initialized; // 读取最新值
}
/**
* 错误使用volatile的场景：复合操作
*/
public void unsafeIncrement() {
counter++; // 仍然不是线程安全的！
// volatile只保证可见性，不保证原子性
}
/**
* 正确的做法：结合CAS操作
*/
private final AtomicInteger atomicCounter = new AtomicInteger(0);
public int safeIncrement() {
return atomicCounter.incrementAndGet();
}
private void performInitialization() {
// 模拟初始化过程
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
📋 最佳实践与设计原则
1. 无状态设计 (首选方案)
/**
* 无状态Service设计 - 最佳实践
*/
@Service
public class StatelessUserService {
@Autowired
private UserRepository userRepository;
@Autowired
private EmailService emailService;
/**
* 无状态方法 - 天然线程安全
* 所有数据通过参数传入，通过返回值传出
*/
public UserDTO createUser(CreateUserRequest request) {
// 1. 验证输入参数
validateUserRequest(request);
// 2. 创建用户实体
User user = new User();
user.setUsername(request.getUsername());
user.setEmail(request.getEmail());
user.setCreatedTime(LocalDateTime.now());
// 3. 保存到数据库
User savedUser = userRepository.save(user);
// 4. 发送欢迎邮件
emailService.sendWelcomeEmail(savedUser.getEmail());
// 5. 返回DTO
return convertToDTO(savedUser);
}
/**
* 查询方法 - 无状态
*/
public List<UserDTO> findUsersByDepartment(String department) {
List<User> users = userRepository.findByDepartment(department);
return users.stream()
.map(this::convertToDTO)
.collect(Collectors.toList());
}
private void validateUserRequest(CreateUserRequest request) {
if (request.getUsername() == null || request.getUsername().trim().isEmpty()) {
throw new IllegalArgumentException("用户名不能为空");
}
// 其他验证逻辑...
}
private UserDTO convertToDTO(User user) {
UserDTO dto = new UserDTO();
dto.setId(user.getId());
dto.setUsername(user.getUsername());
dto.setEmail(user.getEmail());
return dto;
}
}
2. 不可变对象设计
/**
* 不可变对象 - 天然线程安全
*/
public final class ImmutableUserInfo {
private final String userId;
private final String username;
private final String email;
private final LocalDateTime createdTime;
private final List<String> roles;
public ImmutableUserInfo(String userId, String username, String email,
LocalDateTime createdTime, List<String> roles) {
this.userId = userId;
this.username = username;
this.email = email;
this.createdTime = createdTime;
// 防御性拷贝
this.roles = Collections.unmodifiableList(new ArrayList<>(roles));
}
// 只提供getter方法，没有setter
public String getUserId() { return userId; }
public String getUsername() { return username; }
public String getEmail() { return email; }
public LocalDateTime getCreatedTime() { return createdTime; }
public List<String> getRoles() { return roles; }
/**
* 创建修改后的新对象（而不是修改当前对象）
*/
public ImmutableUserInfo withEmail(String newEmail) {
return new ImmutableUserInfo(userId, username, newEmail, createdTime, roles);
}
public ImmutableUserInfo addRole(String role) {
List<String> newRoles = new ArrayList<>(roles);
newRoles.add(role);
return new ImmutableUserInfo(userId, username, email, createdTime, newRoles);
}
}
/**
* 使用不可变对象的Service
*/
@Service
public class ImmutableUserService {
private final Map<String, ImmutableUserInfo> userCache = new ConcurrentHashMap<>();
public void cacheUser(ImmutableUserInfo userInfo) {
// 不可变对象可以安全地在多线程间共享
userCache.put(userInfo.getUserId(), userInfo);
}
public ImmutableUserInfo getUser(String userId) {
return userCache.get(userId);
}
public void updateUserEmail(String userId, String newEmail) {
userCache.computeIfPresent(userId, (key, oldUserInfo) ->
oldUserInfo.withEmail(newEmail) // 创建新对象
);
}
}
3. 合理使用缓存
/**
* 线程安全的缓存实现
*/
@Service
public class ThreadSafeCacheService {
// 使用ConcurrentHashMap实现线程安全缓存
private final ConcurrentHashMap<String, UserDTO> userCache = new ConcurrentHashMap<>();
// 缓存过期时间管理
private final ConcurrentHashMap<String, Long> cacheTimestamps = new ConcurrentHashMap<>();
private static final long CACHE_TTL = 5 * 60 * 1000; // 5分钟
@Autowired
private UserRepository userRepository;
/**
* 线程安全的缓存获取
*/
public UserDTO getUser(String userId) {
// 检查缓存是否过期
if (isCacheExpired(userId)) {
removeFromCache(userId);
}
// 使用computeIfAbsent原子操作
return userCache.computeIfAbsent(userId, this::loadUserFromDatabase);
}
/**
* 原子的缓存更新操作
*/
public void updateUser(String userId, UserDTO userDTO) {
userCache.put(userId, userDTO);
cacheTimestamps.put(userId, System.currentTimeMillis());
// 同时更新数据库
updateUserInDatabase(userDTO);
}
/**
* 安全的缓存清理
*/
public void evictExpiredEntries() {
long currentTime = System.currentTimeMillis();
// 找出过期的键
Set<String> expiredKeys = cacheTimestamps.entrySet().stream()
.filter(entry -> currentTime - entry.getValue() > CACHE_TTL)
.map(Map.Entry::getKey)
.collect(Collectors.toSet());
// 批量清理
expiredKeys.forEach(this::removeFromCache);
}
private boolean isCacheExpired(String userId) {
Long timestamp = cacheTimestamps.get(userId);
return timestamp == null ||
(System.currentTimeMillis() - timestamp) > CACHE_TTL;
}
private void removeFromCache(String userId) {
userCache.remove(userId);
cacheTimestamps.remove(userId);
}
private UserDTO loadUserFromDatabase(String userId) {
User user = userRepository.findById(userId)
.orElseThrow(() -> new UserNotFoundException("用户不存在: " + userId));
UserDTO dto = convertToDTO(user);
// 记录缓存时间
cacheTimestamps.put(userId, System.currentTimeMillis());
return dto;
}
private void updateUserInDatabase(UserDTO userDTO) {
// 更新数据库的逻辑
User user = userRepository.findById(userDTO.getId())
.orElseThrow(() -> new UserNotFoundException("用户不存在"));
user.setUsername(userDTO.getUsername());
user.setEmail(userDTO.getEmail());
userRepository.save(user);
}
private UserDTO convertToDTO(User user) {
// 转换逻辑
return new UserDTO(user.getId(), user.getUsername(), user.getEmail());
}
}
4. 异步处理模式
/**
* 异步处理避免线程安全问题
*/
@Service
public class AsyncProcessingService {
@Async("taskExecutor")
public CompletableFuture<String> processUserDataAsync(String userId) {
try {
// 每个异步任务都有自己的线程栈
// 避免了共享状态的线程安全问题
String result = processUserData(userId);
return CompletableFuture.completedFuture(result);
} catch (Exception e) {
CompletableFuture<String> future = new CompletableFuture<>();
future.completeExceptionally(e);
return future;
}
}
/**
* 批量异步处理
*/
public CompletableFuture<List<String>> processMultipleUsersAsync(List<String> userIds) {
List<CompletableFuture<String>> futures = userIds.stream()
.map(this::processUserDataAsync)
.collect(Collectors.toList());
return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
.thenApply(v -> futures.stream()
.map(CompletableFuture::join)
.collect(Collectors.toList()));
}
private String processUserData(String userId) {
// 模拟耗时处理
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException("处理被中断", e);
}
return "处理完成: " + userId;
}
}
⚡ 性能对比与选择指南
性能测试对比
/**
* 不同线程安全方案的性能测试
*/
@Component
public class PerformanceComparison {
public void comparePerformance() throws InterruptedException {
int threadCount = 100;
int operationsPerThread = 100000;
System.out.println("=== 线程安全方案性能对比 ===");
// 1. synchronized方法测试
testSynchronizedPerformance(threadCount, operationsPerThread);
// 2. AtomicInteger测试
testAtomicPerformance(threadCount, operationsPerThread);
// 3. ThreadLocal测试
testThreadLocalPerformance(threadCount, operationsPerThread);
// 4. 无锁设计测试
testLockFreePerformance(threadCount, operationsPerThread);
}
private void testSynchronizedPerformance(int threadCount, int operations)
throws InterruptedException {
SynchronizedCounter counter = new SynchronizedCounter();
long startTime = System.currentTimeMillis();
CountDownLatch latch = new CountDownLatch(threadCount);
for (int i = 0; i < threadCount; i++) {
new Thread(() -> {
try {
for (int j = 0; j < operations; j++) {
counter.increment();
}
} finally {
latch.countDown();
}
}).start();
}
latch.await();
long endTime = System.currentTimeMillis();
System.out.printf("Synchronized: %d ms, 结果: %d%n",
endTime - startTime, counter.getValue());
}
private void testAtomicPerformance(int threadCount, int operations)
throws InterruptedException {
AtomicInteger counter = new AtomicInteger(0);
long startTime = System.currentTimeMillis();
CountDownLatch latch = new CountDownLatch(threadCount);
for (int i = 0; i < threadCount; i++) {
new Thread(() -> {
try {
for (int j = 0; j < operations; j++) {
counter.incrementAndGet();
}
} finally {
latch.countDown();
}
}).start();
}
latch.await();
long endTime = System.currentTimeMillis();
System.out.printf("AtomicInteger: %d ms, 结果: %d%n",
endTime - startTime, counter.get());
}
// 辅助类
static class SynchronizedCounter {
private int value = 0;
public synchronized void increment() {
value++;
}
public synchronized int getValue() {
return value;
}
}
}
选择指南
| 场景 | 推荐方案 | 原因 |
|---|---|---|
| 简单计数器 | AtomicInteger | 高性能，无锁实现 |
| 状态标志 | volatile | 轻量级，适合简单标志位 |
| 复杂业务逻辑 | 无状态设计 | 天然线程安全，易维护 |
| 用户上下文 | ThreadLocal | 线程隔离，避免参数传递 |
| 缓存场景 | ConcurrentHashMap | 高并发读写性能 |
| 低频更新 | synchronized | 简单可靠，适合低并发 |
🎯 总结与建议
核心要点回顾
- Spring单例本质：容器级单例，所有注入点共享同一实例
- 线程安全问题：实例变量在多线程环境下存在竞态条件
- 解决方案优先级：无状态设计 > 原子类 > ThreadLocal > synchronized
- 性能考量：原子类 > ThreadLocal > synchronized > 重量级锁
最佳实践建议
✅ 推荐做法：
- 优先设计无状态的Service
- 使用不可变对象传递数据
- 合理使用原子类处理简单计数
- ThreadLocal用于用户上下文隔离
- 及时清理ThreadLocal防止内存泄漏
❌ 避免做法：
- 在单例Bean中使用可变的实例变量
- 过度使用synchronized导致性能问题
- 忽略ThreadLocal的内存泄漏风险
- 将线程安全问题留给使用者处理
面试要点
常见面试问题：
Spring Bean默认是单例的，如何保证线程安全？
- 答案：通过无状态设计、原子类、ThreadLocal等方式
Spring单例和Singleton模式有什么区别？
- 答案：Spring是容器级单例，Singleton是JVM级单例
什么情况下Spring Bean不是线程安全的？
- 答案：Bean中有可变的实例变量时
如何解决Spring单例Bean的线程安全问题？
- 答案：多种方案对比，重点说明无状态设计的优势
通过深入理解Spring单例模式的本质和线程安全机制，我们能够编写出既高效又安全的Spring应用程序。记住，无状态设计是最佳实践，它不仅解决了线程安全问题，还让代码更加清晰和易于测试。