面试题：Spring 的单例 Bean 是否有并发安全问题？

是的，Spring 的单例 Bean 可能存在并发安全问题，但这取决于 Bean 的实现方式。Spring 的单例 Bean 默认是线程共享的，即所有线程都使用同一个 Bean 实例。如果 Bean 的状态是可变的（即有成员变量），并且没有正确地处理并发访问，就可能导致线程安全问题。

---

1. 单例 Bean 的并发安全问题

问题原因

• 单例 Bean 是线程共享的：Spring 容器中只有一个单例 Bean 实例，所有请求共享该实例。
• 可变状态：如果 Bean 中有成员变量（状态），并且多个线程同时修改这些变量，就会导致数据不一致或脏数据问题。

示例

@Service
public class CounterService {
    private int count = 0; // 可变状态

    public void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

• 问题：
• 如果多个线程同时调用 increment() 方法，count 的值可能会被错误地更新，导致数据不一致。

---

2. 如何解决单例 Bean 的并发安全问题

2.1 使用无状态 Bean

• 无状态 Bean：Bean 中没有成员变量，所有操作都基于方法参数或局部变量。
• 优点：无状态 Bean 是线程安全的，因为每个线程都有自己的方法栈。

@Service
public class StatelessService {
    public int add(int a, int b) {
        return a + b; // 无状态，线程安全
    }
}

2.2 使用线程安全的类

• 如果 Bean 中必须使用可变状态，可以使用线程安全的类（如 AtomicInteger、ConcurrentHashMap 等）。

@Service
public class CounterService {
    private AtomicInteger count = new AtomicInteger(0); // 线程安全的计数器

    public void increment() {
        count.incrementAndGet();
    }

    public int getCount() {
        return count.get();
    }
}

2.3 使用同步机制

• 使用 synchronized 关键字或 ReentrantLock 来保护共享资源。

@Service
public class CounterService {
    private int count = 0;
    private final Object lock = new Object(); // 锁对象

    public void increment() {
        synchronized (lock) {
            count++;
        }
    }

    public int getCount() {
        synchronized (lock) {
            return count;
        }
    }
}

2.4 使用 ThreadLocal

• 如果状态需要与线程绑定，可以使用 ThreadLocal，每个线程都有自己独立的状态副本。

@Service
public class UserContext {
    private ThreadLocal<String> currentUser = new ThreadLocal<>();

    public void setUser(String user) {
        currentUser.set(user);
    }

    public String getUser() {
        return currentUser.get();
    }

    public void clear() {
        currentUser.remove();
    }
}

2.5 使用原型作用域（Prototype Scope）

• 将 Bean 的作用域设置为原型（@Scope("prototype")），每次请求都会创建一个新的 Bean 实例。
• 缺点：可能会增加内存开销。

@Service
@Scope("prototype")
public class PrototypeService {
    private int count = 0;

    public void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

---

3. 总结

• 单例 Bean 的并发安全问题：
  • 如果 Bean 有可变状态，并且没有正确处理并发访问，就会导致线程安全问题。
• 解决方案：
  1. 使用无状态 Bean。
  2. 使用线程安全的类（如 AtomicInteger、ConcurrentHashMap）。
  3. 使用同步机制（如 synchronized 或 ReentrantLock）。
  4. 使用 ThreadLocal 绑定线程状态。
  5. 使用原型作用域（@Scope("prototype")）。

在实际开发中，应尽量避免在单例 Bean 中使用可变状态。如果必须使用可变状态，则需要确保线程安全。