Spring Bean 是单例的吗？如何保证并发安全？

引言

面试中，经常会被问到这样一个问题：“Spring Bean 是单例的吗？如果是单例如何保证并发安全呢？”，这两个问题看似没有关联，其实一点也不挨着 😂，为什么呢？请听我来“狡辩”。

首先，单例 Bean 本身并不会直接导致线程安全问题。真正影响线程安全性的因素是该单例对象是否包含共享可变状态，以及在进行并发访问时会不会因为共享可变状态而造成了数据不一致的现象。

其实，面试官问这样一个问题，大约是想考察以下几点内容：

• 对 Spring Bean 作用域的理解
• 并发编程相关的知识（线程安全、同步机制等）
• 实际项目中类似问题的处理经验

好了，了解了面试官的意图后，我们从这几个方面来看下这个问题应该如何回答。

Spring 中 Bean 的作用域

Spring 官方定义的 Bean Scopes 有如下几种，出自 Spring 5.1.6.RELEASE 版本文档

• singleton：Spring 中默认的作用域。被定义为 singleton 的 Bean 实例，在第一次被请求获取时创建出来，并缓存起来供后续使用。也就是说，在整个 Spring 容器中，该 Bean 只有一个实例存在。无论你多少次请求这个 Bean，Spring 都会返回同一个对象实例。

• prototype：表示每次获取该 Bean 时，Spring 容器都会创建一个新的实例。这种作用域适用于那些不应该被共享的对象，例如有状态的 Bean。

• request：在 Web 应用程序中，request 作用域的 Bean 在一次 HTTP 请求期间有效。对于每个新的 HTTP 请求，Spring 会创建该 Bean 的一个新实例。一旦请求完成，Bean 就会被销毁。每个请求都有其独立的 Bean 实例，这非常适合处理与特定请求相关的状态信息，如表单数据或用户认证信息。

• session：类似于 request 作用域，但 session 作用域的 Bean 在一个 HTTP Session 期间有效。也就是说，在同一个用户 Session 内，所有对这个 Bean 的请求都将共享同一个实例；而当 Session 结束时，Bean 也会被销毁。适用于存储用户的会话等相关信息。

• application：这个作用域的 Bean 在 ServletContext（即整个 Web 应用程序）的生命周期内有效。这意味着在整个应用程序运行期间，只会存在一个这样的 Bean 实例，类似于 singleton，但它是在 ServletContext 中唯一的，而不是在整个 Spring 容器中唯一的。

• websocket：这个作用域的 Bean 在 WebSocket 连接期间有效。意思是每个 WebSocket 连接都有自己的 Bean 实例，这些实例仅在该连接存活期间可用。当 WebSocket 连接关闭时，Bean 实例将被销毁。

Spring 中也支持自定义 Scope（这里不做赘述）：

• 实现 org.springframework.beans.factory.config.Scope 接口
• 调用 org.springframework.beans.factory.config.ConfigurableBeanFactory#registerScope 方法注册到容器中

单例 Bean 如何保证并发安全？

线程安全问题引发因素

• 多线程：多线程的运行环境，同一个程序中，多个线程并发执行。
• 产生竞态条件：当一个对象内部包含可变状态时，就可能产生竞态条件（Race Condition），即不同线程之间的操作顺序会影响最终结果。

示例：假设有一个单例 Bean 处理订单业务逻辑，并且它维护了一个内部计数器来跟踪订单数量。如果不采取任何同步措施，多个线程同时调用该 placeOrder 方法可能会导致计数器值错误。

@Component
public class OrderService {
    private int orderCount = 0;
    public void placeOrder() {
        orderCount++; // 可能发生竞态条件
        System.out.println("Placed order, total orders: " + orderCount);
    }
}

解决方案

• 无状态设计：尽量设计成无状态的 Bean，即 Bean 不持有任何可变状态。这样即使多个线程同时访问也不会有问题。对于确实需要维护状态的情况，可以通过参数传递或外部化状态来实现。

@Component
public class StatelessOrderService {
    // 不再维护订单状态
    public void placeOrder(Order order) {
        // 订单处理逻辑
        System.out.println("Placed order: " + order.getId());
    }
}

什么是无状态与有状态对象？

无状态的对象 (Stateless Object)：无状态对象是指那些不保持任何内部状态的对象。它们的行为完全由方法参数决定，这意味着每次调用相同的方法并传入相同的参数，都将得到一致的结果，而不受之前操作的影响。

有状态的对象 (Stateful Object)：有状态对象维护内部状态，并且这些状态可能会影响对象的行为。这种状态通常是通过成员变量存储的，在对象的生命期内可以发生变化。

• 不可变对象：如果一个对象一旦创建后就不会改变，那么它自然是线程安全的。通过使用 final 关键字确保字段不可修改，并避免对外暴露可变状态。

public final class ImmutableOrder {
    private final String id;
    private final String customerName;

    public ImmutableOrder(String id, String customerName) {
        this.id = id;
        this.customerName = customerName;
    }

    public String getId() {
        return id;
    }

    public String getCustomerName() {
        return customerName;
    }
}

• 同步机制：对于那些需要维护内部状态的 Bean，可以通过 synchronized 关键字来同步方法或代码块，从而确保同一时刻只有一个线程能够访问这些方法或代码块。还可以使用更细粒度的锁机制，如 ReentrantLock。

@Component
public class SynchronizedOrderService {
    private int orderCount = 0;

    public synchronized void placeOrder() {
        orderCount++;
        System.out.println("Placed order, total orders: " + orderCount);
    }
}

• 线程安全的数据结构：使用 JUC(java.util.concurrent) 提供的线程安全集合类（如 ConcurrentHashMap、CopyOnWriteArrayList）和原子变量（如 AtomicInteger、AtomicLong）等，可以在不加锁的情况下完成对数值的操作，提高性能。

import java.util.concurrent.ConcurrentHashMap;

@Component
public class ThreadSafeOrderService {
    private final Map<String, Integer> orderCounts = new ConcurrentHashMap<>();

    public void placeOrder(String customerId) {
        orderCounts.compute(customerId, (id, count) -> count == null ? 1 : count + 1);
        System.out.println("Placed order for customer " + customerId + ", total orders: " + orderCounts.get(customerId));
    }
}

import java.util.concurrent.atomic.AtomicInteger;

@Component
public class AtomicOrderService {
    private final AtomicInteger orderCount = new AtomicInteger(0);

    public void placeOrder() {
        int currentCount = orderCount.incrementAndGet();
        System.out.println("Placed order, total orders: " + currentCount);
    }
}

• ThreadLocal 变量：利用 ThreadLocal 提供的每个线程私有的变量副本，可以避免多个线程之间互相干扰。如果需要在线程间传递上下文时可以使用这种方式。

import java.util.HashMap;
import java.util.Map;

@Component
public class ThreadLocalOrderService {
    private static final ThreadLocal<Map<String, Integer>> threadLocalOrders = ThreadLocal.withInitial(HashMap::new);

    public void placeOrder(String customerId) {
        Map<String, Integer> orders = threadLocalOrders.get();
        orders.merge(customerId, 1, Integer::sum);
        System.out.println("Placed order for customer " + customerId + ", total orders in this thread: " + orders.get(customerId));
    }
}

结语

当然，前面提到的一些控制并发的手段（如同步机制、原子变量、ThreadLocal 等）可以在一定程度上帮助解决本地线程安全问题，但是在分布式服务环境中，确保并发安全的挑战更为复杂，因为不仅需要处理单个应用程序内的多线程问题，还需要应对跨多个节点的并发访问。彼时，我们可以借助 Redis、Zookeeper 等分布式中间件来控制多个服务节点的并发。

---

更多精彩内容，请微信搜索并关注【Java驿站】公众号。