Skip to content
TungDaDev's Blog

Singleton pattern: volatile trong DCL, Enum và Spring bean

Singleton pattern.webp
Published on
13 mins read

Một comment review ngắn gọn: "Biến instance thiếu volatile." Người viết cãi: đã có synchronized rồi mà, lại còn check null hai lần.

Đoạn Double-Checked Locking (DCL) đó có thể chạy ngon cả năm rồi một hôm trả về một object chưa khởi tạo xong. Nhìn lướt qua, Singleton là mẫu dễ nhất trong 23 mẫu GoF: một private constructor và một hàm static getInstance(). Đặt vào môi trường đa luồng của JVM thì khác. JIT và CPU có thể đảo thứ tự lệnh, làm lộ đối tượng chưa khởi tạo xong (partially-constructed object). Reflection hay Deserialization có thể phá tính duy nhất. Còn ở tầng kiến trúc, nó bị xem là anti-pattern vì đi ngược nguyên lý Dependency Inversion.

Đó cũng là lý do Joshua Bloch (tác giả Effective Java) khuyên dùng Enum Singleton, còn dự án Spring hiện đại thì gần như không ai tự viết getInstance() nữa mà giao hết cho IoC Container.


# tại sao double-checked locking phải có volatile?

Đây là đoạn DCL kinh điển, thiếu volatile thì sẽ dính lỗi lúc có lúc không (Heisenbug):

public class UnsafeDCLSingleton {
    // THẢM HỌA: Thiếu từ khóa volatile!
    private static UnsafeDCLSingleton instance;
 
    private UnsafeDCLSingleton() {}
 
    public static UnsafeDCLSingleton getInstance() {
        if (instance == null) { // Lần check 1 (Không lock để tối ưu tốc độ)
            synchronized (UnsafeDCLSingleton.class) {
                if (instance == null) { // Lần check 2 (Có lock để đảm bảo duy nhất)
                    instance = new UnsafeDCLSingleton(); // ĐIỂM CHẾT NẰM Ở ĐÂY!
                }
            }
        }
        return instance;
    }
}

# bản chất của lỗi instruction reordering

instance = new Singleton(); không phải thao tác nguyên tử (atomic). Ở tầng bytecode nó gồm các lệnh new, dup, invokespecial, putstatic, về mặt ý nghĩa là 3 bước:

  1. new: cấp vùng nhớ trên heap (các field mang giá trị mặc định null/0).
  2. invokespecial <init>: chạy constructor để khởi tạo các field.
  3. putstatic: gán địa chỉ vùng nhớ vừa cấp vào biến instance.

Trong cùng một thread, thứ tự 1 → 2 → 3 luôn được tôn trọng về mặt kết quả (as-if-serial semantics). Nhưng Java Memory Model (JMM) không bắt buộc một thread khác phải nhìn thấy các thao tác ghi bộ nhớ theo đúng thứ tự đó nếu giữa hai thread không thiết lập quan hệ happens-before. Thực tế, trình biên dịch JIT hoàn toàn có quyền inline constructor rồi đảo lệnh gán địa chỉ vào biến instance lên trước khi ghi xong các field bên trong, và trên các kiến trúc CPU nới lỏng thứ tự bộ nhớ như ARM thì phần cứng cũng có thể làm vậy, khiến thread khác quan sát thấy thứ tự thực thi biến thành 1 -> 3 -> 2.

Hãy hình dung kịch bản khi chuyện đảo lệnh đó xảy ra: ngay khi Thread 1 vừa chạy xong bước 3 mà chưa kịp chạy bước 2, vùng nhớ đã được gán nên biến instance lập tức khác null. Đúng khoảnh khắc đó, Thread 2 nhảy vào gọi getInstance(); vì lần kiểm tra if (instance == null) đầu tiên nằm ngoài khối synchronized (không có khoá hay volatile), Thread 2 thấy instance != null nên lấy thẳng tham chiếu đó trả về luôn. Hậu quả là Thread 2 cầm trên tay một đối tượng bán phần (Partially-Constructed Object) mà constructor chưa chạy xong, các trường dữ liệu bên trong vẫn mang giá trị mặc định null hoặc 0, dẫn tới những lỗi NullPointerException xuất hiện ngẫu nhiên lúc có lúc không trên Production.

# vai trò của volatile và memory barrier

Từ Java 5 (JSR-133), ngữ nghĩa của từ khoá volatile được siết chặt lại trong Java Memory Model. Khi bạn khai báo private static volatile SafeDCLSingleton instance;, JVM sẽ chèn các memory barrier (hàng rào bộ nhớ) ở tầng mã máy (chẳng hạn hàng rào StoreStore trước khi ghi vào instance), cấm tiệt việc dời các lệnh ghi field bên trong constructor ra phía sau lệnh gán instance. Đồng thời, ghi vào biến volatile tạo ra một quan hệ happens-before với mọi lần đọc biến đó về sau: bất kỳ luồng nào đọc thấy instance != null đều được bảo đảm nhìn thấy đầy đủ toàn bộ các giá trị mà constructor đã thiết lập. (Lưu ý nhỏ: trước Java 5, mô hình bộ nhớ cũ vẫn cho phép tái sắp xếp lệnh thường với lệnh volatile, nên DCL thời đó hỏng kể cả khi có volatile, và đó là lý do nhiều tài liệu cũ bảo "đừng bao giờ dùng DCL").

TIP

Quy tắc cần nhớ: Dùng Double-Checked Locking (DCL) trong Java thì biến instance phải có volatile:

private static volatile SafeDCLSingleton instance;

Không có volatile thì DCL là quả bom nổ chậm trên CPU đa lõi.


# bill pugh holder: không cần lock

Muốn khởi tạo lười (Lazy Initialization), an toàn đa luồng mà không tốn chi phí synchronized hay volatile, thì dùng Initialization-on-demand Holder Idiom do Bill Pugh đề xuất:

public class BillPughSingleton {
 
    private BillPughSingleton() {}
 
    // Static nested class chỉ được nạp khi phương thức getInstance() được gọi lần đầu
    private static class LazyHolder {
        private static final BillPughSingleton INSTANCE = new BillPughSingleton();
    }
 
    public static BillPughSingleton getInstance() {
        return LazyHolder.INSTANCE;
    }
}

JVM luôn đồng bộ việc khởi tạo một class (initialization lock, mô tả ở JLS §12.4.2): chỉ một thread chạy static initializer, các thread khác chờ, và việc khởi tạo xong happens-before mọi lần dùng class sau đó. Nhờ vậy không có race condition, mà sau lần đầu thì getInstance() chỉ là đọc một field static bình thường.

Nhược điểm: constructor mà ném exception thì LazyHolder hỏng vĩnh viễn, các lần gọi sau nhận NoClassDefFoundError. Singleton cần khởi tạo có thể thất bại (đọc file, gọi mạng) thì cân nhắc kỹ.


# các cách phá singleton và cách phòng thủ

Có 4 cách phá tính duy nhất của Singleton mà bạn nên biết để phòng:

# cách 1: reflection attack

Dùng Reflection để gọi private constructor:

Constructor<BillPughSingleton> constructor = BillPughSingleton.class.getDeclaredConstructor();
constructor.setAccessible(true);
BillPughSingleton fakeInstance = constructor.newInstance(); // Phá vỡ Singleton!

Phòng thủ: ném exception ngay trong constructor nếu instance đã tồn tại. Cách này chạy được cả khi kẻ tấn công gọi reflection trước getInstance(): đọc LazyHolder.INSTANCE trong constructor sẽ kích hoạt khởi tạo holder (tạo instance thật), rồi lần gọi reflection đó bị chặn. Nhưng nó chỉ là rào chắn, ai đã chủ động dùng reflection thì vẫn có thể sửa luôn field INSTANCE:

private BillPughSingleton() {
    if (LazyHolder.INSTANCE != null) {
        throw new IllegalStateException("Hành vi tạo đối tượng qua Reflection bị cấm!");
    }
}

# cách 2: serialization attack

Khi Singleton implements Serializable, mỗi lần deserialize sẽ tạo một instance mới mà không gọi constructor của class (JVM chỉ gọi constructor không tham số của lớp cha gần nhất không Serializable, ở đây là Object).

Phòng thủ: định nghĩa method readResolve(), và đánh dấu các field là transient:

@Serial
private Object readResolve() {
    // Thay thế đối tượng vừa deserialize bằng instance duy nhất trong bộ nhớ
    return getInstance();
}

Hai cách còn lại ngắn hơn. Clone chỉ là vấn đề khi Singleton (hoặc lớp cha của nó) implements Cloneable; phòng thủ bằng cách không implement, hoặc override clone() để ném CloneNotSupportedException. Nhiều ClassLoader thì không chặn được từ bên trong class: mỗi ClassLoader nạp class là một class khác nhau với static riêng, nên có bao nhiêu ClassLoader là bấy nhiêu "singleton". Chuyện này hay gặp ở app server có nhiều webapp, hoặc khi Spring Boot DevTools dùng restart ClassLoader.


# enum singleton

Trong Effective Java (Item 3, bản 3), Joshua Bloch viết: "A single-element enum type is often the best way to implement a singleton." Chữ "often" là có lý do: enum không kế thừa được class khác, và không khởi tạo lười được như holder (instance tạo ngay khi enum được nạp).

public enum EnterpriseConfigurationManager {
    INSTANCE;
 
    private final Map<String, String> configs = new ConcurrentHashMap<>();
 
    public void setConfig(String key, String value) {
        configs.put(key, value);
    }
 
    public String getConfig(String key) {
        return configs.get(key);
    }
}

# tại sao enum chống được hết?

Sở dĩ Enum miễn nhiễm với các đòn phá hoại thông thường là nhờ được bảo vệ ngay từ tầng JDK và JVM. Với Reflection, chính phương thức Constructor.newInstance() trong thư viện chuẩn của JDK có sẵn một chốt chặn kiểm tra cờ Modifier.ENUM và ném lỗi ngay lập tức nếu ai đó cố tình gọi:

if ((clazz.getModifiers() & Modifier.ENUM) != 0)
    throw new IllegalArgumentException("Cannot reflectively create enum objects");

Với Serialization, đặc tả Java quy định enum chỉ được ghi xuống luồng byte bằng tên định danh chuỗi (name()) chứ không ghi trạng thái object, và khi đọc lên thì tìm lại hằng số có sẵn qua Enum.valueOf(), nên không bao giờ đẻ ra instance thứ hai dù bạn không viết readResolve(). Còn chuyện khởi tạo đa luồng thì đã được cơ chế nạp lớp của JVM bảo đảm sẵn giống như Bill Pugh Holder. Tất nhiên, bản thân Enum chỉ đảm bảo có duy nhất một vỏ INSTANCE, còn các trường trạng thái bên trong (như configs ở ví dụ trên) nếu cho phép nhiều luồng vừa đọc vừa sửa thì bạn vẫn phải tự dùng cấu trúc dữ liệu an toàn đa luồng như ConcurrentHashMap.


# tại sao gof singleton bị xem là anti-pattern?

GoF Singleton là mẫu kinh điển, nhưng trong kiến trúc hiện đại (microservices, Clean Architecture, DDD), singleton kiểu static truyền thống thường bị xem là anti-pattern. Vấn đề không nằm ở chuyện "chỉ có một instance", mà ở chỗ ai cũng lấy được nó qua một lời gọi static, giống biến toàn cục đội lốt class:

# so sánh gof singleton vs spring singleton scope

Tiêu chíGoF Singleton (Static Instance)Spring Singleton (@Component / @Service)
Phạm vi duy nhất (Scope)Duy nhất trên mỗi ClassLoader của JVMDuy nhất trên mỗi Spring ApplicationContext
Khả năng Unit TestKhó, phải dùng Mockito.mockStatic (trước đây PowerMock)Rất dễ, truyền mock qua constructor là xong
Tính liên kết (Coupling)Phụ thuộc cứng (Tight Coupling)Khớp nối lỏng (Loose Coupling) qua Dependency Injection
Quản lý vòng đờiSống tới khi ClassLoader bị thu hồi (thường là hết JVM)Hỗ trợ @PostConstruct, @PreDestroy, Graceful Shutdown

# cách làm trong spring boot

public interface CurrencyExchangeRateProvider {
    BigDecimal getRate(String from, String to);
}
 
// Spring tự động quản lý Bean này như một Singleton Scope trong ApplicationContext
@Service
public class CentralBankExchangeRateProvider implements CurrencyExchangeRateProvider {
 
    private final RestClient restClient;
 
    public CentralBankExchangeRateProvider(RestClient.Builder restClientBuilder) {
        this.restClient = restClientBuilder.baseUrl("https://api.centralbank.gov").build();
    }
 
    @Override
    public BigDecimal getRate(String from, String to) {
        // Thực thi gọi API
        return BigDecimal.ONE;
    }
}

# checklist

  • Kiểm tra volatile trong DCL: dùng Double-Checked Locking thì biến instance phải có volatile.
  • Ưu tiên Bill Pugh hoặc Enum: ứng dụng Java Core không dùng Spring thì nên dùng Initialization-on-demand Holder hoặc Enum Singleton thay cho DCL.
  • Phòng vệ Serialization: class Singleton buộc phải implements Serializable thì thêm readResolve().
  • Thay bằng Spring Bean: trong dự án Spring Boot, bỏ các lớp Singleton tự viết (getInstance()), chuyển sang @Service hoặc @Component để Spring IoC Container quản lý.
  • Bean singleton phải stateless hoặc thread-safe: một bean singleton được mọi request, mọi thread (và mọi tenant, nếu hệ thống multi-tenant) dùng chung. Đừng giữ dữ liệu theo request/user trong field của bean; cần thì dùng scope request, truyền qua tham số, hoặc cấu trúc thread-safe.

# kết luận

Muốn rà nhanh một codebase cũ thì grep getInstance() trước. Mỗi chỗ tìm thấy, xem nó là DCL (kiểm tra volatile), holder hay enum. Nếu project đã dùng Spring thì đó là ứng viên để chuyển thành bean, vì singleton tự viết rất khó mock trong test. Phần Java Memory Model đằng sau chữ volatile có bài riêng: Java Memory Model & happens-before.

Mỗi cách triển khai có cái giá riêng: DCL dễ sai khi thiếu volatile, holder gọn nhưng hỏng vĩnh viễn nếu constructor lỗi, enum phòng thủ tốt nhưng kém linh hoạt, còn Spring IoC Container thì dễ test nhất. Viết thư viện Java thuần thì holder hoặc enum; dự án Spring thì cứ để container lo.


Chỉ là những ghi chép cá nhân với hy vọng mang lại chút giá trị. Nếu thấy hữu ích, đừng ngại chia sẻ cho bạn bè & đồng nghiệp nhé!

Happy coding 😎 👍🏻 🚀 🔥.