引言

面試中，經(jīng)常會被問到這樣一個問題：“Spring Bean 是單例的嗎？如果是單例如何保證并發(fā)安全呢？”，這兩個問題看似沒有關(guān)聯(lián)，其實一點也不挨著，為什么呢？請聽我來“狡辯”。

首先，單例Bean 本身并不會直接導(dǎo)致線程安全問題。真正影響線程安全性的因素是該單例對象是否包含共享可變狀態(tài)，以及在進行并發(fā)訪問時會不會因為共享可變狀態(tài)而造成了數(shù)據(jù)不一致的現(xiàn)象。

其實，面試官問這樣一個問題，大約是想考察以下幾點內(nèi)容：

• 對Spring Bean 作用域的理解
• 并發(fā)編程相關(guān)的知識（線程安全、同步機制等）
• 實際項目中類似問題的處理經(jīng)驗

好了，了解了面試官的意圖后，我們從這幾個方面來看下這個問題應(yīng)該如何回答。

Spring 中 Bean 的作用域

Spring 官方定義的Bean Scopes 有如下幾種，出自Spring 5.1.6.RELEASE 版本文檔

圖片

Bean scopes

• singleton：Spring 中默認的作用域。被定義為singleton 的Bean 實例，在第一次被請求獲取時創(chuàng)建出來，并緩存起來供后續(xù)使用。也就是說，在整個Spring 容器中，該Bean 只有一個實例存在。無論你多少次請求這個Bean，Spring 都會返回同一個對象實例。
• prototype：表示每次獲取該Bean 時，Spring 容器都會創(chuàng)建一個新的實例。這種作用域適用于那些不應(yīng)該被共享的對象，例如有狀態(tài)的Bean。
• request：在Web 應(yīng)用程序中，request 作用域的Bean 在一次HTTP 請求期間有效。對于每個新的HTTP 請求，Spring 會創(chuàng)建該Bean 的一個新實例。一旦請求完成，Bean 就會被銷毀。每個請求都有其獨立的Bean 實例，這非常適合處理與特定請求相關(guān)的狀態(tài)信息，如表單數(shù)據(jù)或用戶認證信息。
• session：類似于request 作用域，但session 作用域的Bean 在一個HTTP Session 期間有效。也就是說，在同一個用戶Session 內(nèi)，所有對這個Bean 的請求都將共享同一個實例；而當(dāng)Session 結(jié)束時，Bean 也會被銷毀。適用于存儲用戶的會話等相關(guān)信息。
• application：這個作用域的Bean 在ServletContext（即整個Web 應(yīng)用程序）的生命周期內(nèi)有效。這意味著在整個應(yīng)用程序運行期間，只會存在一個這樣的Bean 實例，類似于singleton，但它是在ServletContext 中唯一的，而不是在整個Spring 容器中唯一的。
• websocket：這個作用域的Bean 在WebSocket 連接期間有效。意思是每個WebSocket 連接都有自己的Bean 實例，這些實例僅在該連接存活期間可用。當(dāng)WebSocket 連接關(guān)閉時，Bean 實例將被銷毀。

Spring 中也支持自定義 Scope（這里不做贅述）：

• 實現(xiàn) org.springframework.beans.factory.config.Scope 接口
• 調(diào)用 org.springframework.beans.factory.config.ConfigurableBeanFactory#registerScope 方法注冊到容器中

單例 Bean 如何保證并發(fā)安全？

線程安全問題引發(fā)因素

• 多線程：多線程的運行環(huán)境，同一個程序中，多個線程并發(fā)執(zhí)行。
• 產(chǎn)生競態(tài)條件：當(dāng)一個對象內(nèi)部包含可變狀態(tài)時，就可能產(chǎn)生競態(tài)條件（Race Condition），即不同線程之間的操作順序會影響最終結(jié)果。

示例：假設(shè)有一個單例Bean 處理訂單業(yè)務(wù)邏輯，并且它維護了一個內(nèi)部計數(shù)器來跟蹤訂單數(shù)量。如果不采取任何同步措施，多個線程同時調(diào)用該placeOrder 方法可能會導(dǎo)致計數(shù)器值錯誤。

@Component
public class OrderService {
    private int orderCount = 0;
    public void placeOrder() {
        orderCount++; // 可能發(fā)生競態(tài)條件
        System.out.println("Placed order, total orders: " + orderCount);
    }
}

解決方案

• 無狀態(tài)設(shè)計：盡量設(shè)計成無狀態(tài)的Bean，即Bean 不持有任何可變狀態(tài)。這樣即使多個線程同時訪問也不會有問題。對于確實需要維護狀態(tài)的情況，可以通過參數(shù)傳遞或外部化狀態(tài)來實現(xiàn)。

@Component
public class StatelessOrderService {
    // 不再維護訂單狀態(tài)
    public void placeOrder(Order order) {
        // 訂單處理邏輯
        System.out.println("Placed order: " + order.getId());
    }
}

什么是無狀態(tài)與有狀態(tài)對象？

無狀態(tài)的對象 (Stateless Object)：無狀態(tài)對象是指那些不保持任何內(nèi)部狀態(tài)的對象。它們的行為完全由方法參數(shù)決定，這意味著每次調(diào)用相同的方法并傳入相同的參數(shù)，都將得到一致的結(jié)果，而不受之前操作的影響。

有狀態(tài)的對象 (Stateful Object)：有狀態(tài)對象維護內(nèi)部狀態(tài)，并且這些狀態(tài)可能會影響對象的行為。這種狀態(tài)通常是通過成員變量存儲的，在對象的生命期內(nèi)可以發(fā)生變化。

• 不可變對象：如果一個對象一旦創(chuàng)建后就不會改變，那么它自然是線程安全的。通過使用final 關(guān)鍵字確保字段不可修改，并避免對外暴露可變狀態(tài)。

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;
    }
}

• 同步機制：對于那些需要維護內(nèi)部狀態(tài)的Bean，可以通過synchronized 關(guān)鍵字來同步方法或代碼塊，從而確保同一時刻只有一個線程能夠訪問這些方法或代碼塊。還可以使用更細粒度的鎖機制，如ReentrantLock。

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

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

• 線程安全的數(shù)據(jù)結(jié)構(gòu)：使用JUC(java.util.concurrent) 提供的線程安全集合類（如ConcurrentHashMap、CopyOnWriteArrayList）和原子變量（如AtomicInteger、AtomicLong）等，可以在不加鎖的情況下完成對數(shù)值的操作，提高性能。

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));
    }
}

結(jié)語

當(dāng)然，前面提到的一些控制并發(fā)的手段（如同步機制、原子變量、ThreadLocal 等）可以在一定程度上幫助解決本地線程安全問題，但是在分布式服務(wù)環(huán)境中，確保并發(fā)安全的挑戰(zhàn)更為復(fù)雜，因為不僅需要處理單個應(yīng)用程序內(nèi)的多線程問題，還需要應(yīng)對跨多個節(jié)點的并發(fā)訪問。彼時，我們可以借助Redis、Zookeeper 等分布式中間件來控制多個服務(wù)節(jié)點的并發(fā)。