Singleton Pattern: Một Instance Duy Nhất Thống Trị Tất Cả

// TypeScript - Lazy Singleton
class Logger {
  private static instance: Logger;
  private logs: string[] = [];
 
  // Private constructor - không ai có thể gọi `new Logger()`
  private constructor() {
    console.log("Logger initialized");
  }
 
  public static getInstance(): Logger {
    if (!Logger.instance) {
      Logger.instance = new Logger();
    }
    return Logger.instance;
  }
 
  public log(message: string): void {
    const entry = `[${new Date().toISOString()}] ${message}`;
    this.logs.push(entry);
    console.log(entry);
  }
 
  public getLogs(): string[] {
    return [...this.logs]; // Trả về bản sao để bảo vệ state nội bộ
  }
}
 
// Sử dụng
const logger1 = Logger.getInstance();
const logger2 = Logger.getInstance();
 
logger1.log("Application started");
logger2.log("User logged in");
 
console.log(logger1 === logger2);       // true — cùng instance
console.log(logger1.getLogs().length);   // 2 — cả hai log ở cùng một nơi

# Python - Lazy Singleton dùng __new__
import threading
from datetime import datetime
 
 
class Logger:
    _instance = None
 
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance._logs = []
            print("Logger initialized")
        return cls._instance
 
    def log(self, message: str) -> None:
        entry = f"[{datetime.now().isoformat()}] {message}"
        self._logs.append(entry)
        print(entry)
 
    def get_logs(self) -> list[str]:
        return self._logs.copy()
 
 
# Sử dụng
logger1 = Logger()
logger2 = Logger()
 
logger1.log("Application started")
logger2.log("User logged in")
 
print(logger1 is logger2)        # True — cùng instance
print(len(logger1.get_logs()))   # 2 — cả hai log ở cùng một nơi

// Java - Lazy Singleton
public class Logger {
    private static Logger instance;
    private final List<String> logs = new ArrayList<>();
 
    // Private constructor
    private Logger() {
        System.out.println("Logger initialized");
    }
 
    public static Logger getInstance() {
        if (instance == null) {
            instance = new Logger();
        }
        return instance;
    }
 
    public void log(String message) {
        String entry = "[" + java.time.Instant.now() + "] " + message;
        logs.add(entry);
        System.out.println(entry);
    }
 
    public List<String> getLogs() {
        return List.copyOf(logs); // Bản sao bất biến
    }
}
 
// Sử dụng
Logger logger1 = Logger.getInstance();
Logger logger2 = Logger.getInstance();
 
logger1.log("Application started");
logger2.log("User logged in");
 
System.out.println(logger1 == logger2);       // true — cùng instance
System.out.println(logger1.getLogs().size());  // 2

// TypeScript - Eager Singleton
class AppConfig {
  // Instance được tạo ngay khi class được load
  private static readonly instance: AppConfig = new AppConfig();
 
  private settings: Map<string, string> = new Map();
 
  private constructor() {
    // Load settings mặc định
    this.settings.set("env", "production");
    this.settings.set("logLevel", "info");
    console.log("AppConfig loaded");
  }
 
  public static getInstance(): AppConfig {
    return AppConfig.instance;
  }
 
  public get(key: string): string | undefined {
    return this.settings.get(key);
  }
 
  public set(key: string, value: string): void {
    this.settings.set(key, value);
  }
}

# Python - Eager Singleton dùng module-level instance
class _AppConfig:
    def __init__(self):
        self._settings: dict[str, str] = {
            "env": "production",
            "log_level": "info",
        }
        print("AppConfig loaded")
 
    def get(self, key: str) -> str | None:
        return self._settings.get(key)
 
    def set(self, key: str, value: str) -> None:
        self._settings[key] = value
 
 
# Module-level instance — được tạo khi module được import lần đầu
config = _AppConfig()
 
 
# Sử dụng (từ module khác):
# from config import config
# config.get("env")  # "production"

// Java - Eager Singleton
public class AppConfig {
    // Instance được tạo khi class được load bởi JVM
    private static final AppConfig INSTANCE = new AppConfig();
 
    private final Map<String, String> settings = new HashMap<>();
 
    private AppConfig() {
        settings.put("env", "production");
        settings.put("logLevel", "info");
        System.out.println("AppConfig loaded");
    }
 
    public static AppConfig getInstance() {
        return INSTANCE;
    }
 
    public String get(String key) {
        return settings.get(key);
    }
 
    public void set(String key, String value) {
        settings.put(key, value);
    }
}

// Điều gì xảy ra khi hai thread gọi getInstance() cùng lúc?
//
// Thread A: kiểm tra instance == null → true
// Thread B: kiểm tra instance == null → true (trước khi A tạo xong!)
// Thread A: tạo instance #1
// Thread B: tạo instance #2  ← Hai instance tồn tại!

// Java - Thread-safe với synchronized
public class Logger {
    private static Logger instance;
 
    private Logger() {}
 
    // synchronized: chỉ một thread có thể vào tại một thời điểm
    public static synchronized Logger getInstance() {
        if (instance == null) {
            instance = new Logger();
        }
        return instance;
    }
}

// Java - Double-checked locking
public class Logger {
    // volatile đảm bảo tất cả threads thấy giá trị mới nhất
    private static volatile Logger instance;
 
    private Logger() {}
 
    public static Logger getInstance() {
        if (instance == null) {                // Kiểm tra lần 1 (không lock)
            synchronized (Logger.class) {      // Lock chỉ khi cần
                if (instance == null) {        // Kiểm tra lần 2 (có lock)
                    instance = new Logger();
                }
            }
        }
        return instance;
    }
}

// Java - Bill Pugh Singleton (dùng inner static class)
public class Logger {
    private final List<String> logs = new ArrayList<>();
 
    private Logger() {
        System.out.println("Logger initialized");
    }
 
    // Inner class không được load cho đến khi getInstance() được gọi
    private static class Holder {
        private static final Logger INSTANCE = new Logger();
    }
 
    public static Logger getInstance() {
        return Holder.INSTANCE;
    }
 
    public void log(String message) {
        String entry = "[" + java.time.Instant.now() + "] " + message;
        logs.add(entry);
        System.out.println(entry);
    }
}

// logger.ts — ES6 module Singleton (không cần class!)
 
const logs: string[] = [];
 
export function log(message: string): void {
  const entry = `[${new Date().toISOString()}] ${message}`;
  logs.push(entry);
  console.log(entry);
}
 
export function getLogs(): string[] {
  return [...logs];
}

// app.ts
import { log, getLogs } from "./logger";
 
log("Application started");
console.log(getLogs().length); // 1

// userService.ts
import { log } from "./logger";
 
log("User logged in");
// Ghi vào CÙNG mảng logs như app.ts

// TypeScript - Database Connection Pool Singleton
interface ConnectionConfig {
  host: string;
  port: number;
  database: string;
  maxConnections: number;
}
 
class DatabasePool {
  private static instance: DatabasePool;
  private connections: string[] = [];
  private config: ConnectionConfig;
 
  private constructor(config: ConnectionConfig) {
    this.config = config;
    this.initializePool();
    console.log(
      `Database pool created: ${config.host}:${config.port}/${config.database}`
    );
  }
 
  public static initialize(config: ConnectionConfig): DatabasePool {
    if (!DatabasePool.instance) {
      DatabasePool.instance = new DatabasePool(config);
    }
    return DatabasePool.instance;
  }
 
  public static getInstance(): DatabasePool {
    if (!DatabasePool.instance) {
      throw new Error(
        "DatabasePool not initialized. Call initialize() first."
      );
    }
    return DatabasePool.instance;
  }
 
  private initializePool(): void {
    for (let i = 0; i < this.config.maxConnections; i++) {
      this.connections.push(`conn-${i}`);
    }
  }
 
  public getConnection(): string {
    const conn = this.connections.pop();
    if (!conn) {
      throw new Error("No available connections in pool");
    }
    console.log(`Checked out connection: ${conn}`);
    return conn;
  }
 
  public releaseConnection(conn: string): void {
    this.connections.push(conn);
    console.log(`Released connection: ${conn}`);
  }
 
  public getAvailableCount(): number {
    return this.connections.length;
  }
}
 
// Khởi động ứng dụng
DatabasePool.initialize({
  host: "localhost",
  port: 5432,
  database: "myapp",
  maxConnections: 10,
});
 
// Trong bất kỳ service nào — nhận cùng pool
const pool = DatabasePool.getInstance();
const conn = pool.getConnection();
// ... sử dụng connection ...
pool.releaseConnection(conn);

# Python - Database Connection Pool Singleton
from dataclasses import dataclass
from collections import deque
 
 
@dataclass
class ConnectionConfig:
    host: str
    port: int
    database: str
    max_connections: int
 
 
class DatabasePool:
    _instance = None
 
    def __new__(cls, config: ConnectionConfig | None = None):
        if cls._instance is None:
            if config is None:
                raise RuntimeError(
                    "DatabasePool not initialized. Pass config on first call."
                )
            cls._instance = super().__new__(cls)
            cls._instance._config = config
            cls._instance._connections = deque(
                f"conn-{i}" for i in range(config.max_connections)
            )
            print(
                f"Database pool created: "
                f"{config.host}:{config.port}/{config.database}"
            )
        return cls._instance
 
    def get_connection(self) -> str:
        if not self._connections:
            raise RuntimeError("No available connections in pool")
        conn = self._connections.pop()
        print(f"Checked out connection: {conn}")
        return conn
 
    def release_connection(self, conn: str) -> None:
        self._connections.append(conn)
        print(f"Released connection: {conn}")
 
    @property
    def available_count(self) -> int:
        return len(self._connections)
 
 
# Khởi động ứng dụng
pool = DatabasePool(ConnectionConfig("localhost", 5432, "myapp", 10))
 
# Trong bất kỳ module nào — cùng instance
pool = DatabasePool()
conn = pool.get_connection()
# ... sử dụng connection ...
pool.release_connection(conn)

// Java - Database Connection Pool Singleton (Bill Pugh pattern)
public class DatabasePool {
    private final Queue<String> connections = new LinkedList<>();
    private final ConnectionConfig config;
 
    private DatabasePool() {
        this.config = ConnectionConfig.load(); // Load từ environment/file
        for (int i = 0; i < config.maxConnections(); i++) {
            connections.add("conn-" + i);
        }
        System.out.printf(
            "Database pool created: %s:%d/%s%n",
            config.host(), config.port(), config.database()
        );
    }
 
    private static class Holder {
        private static final DatabasePool INSTANCE = new DatabasePool();
    }
 
    public static DatabasePool getInstance() {
        return Holder.INSTANCE;
    }
 
    public synchronized String getConnection() {
        if (connections.isEmpty()) {
            throw new RuntimeException("No available connections in pool");
        }
        String conn = connections.poll();
        System.out.println("Checked out connection: " + conn);
        return conn;
    }
 
    public synchronized void releaseConnection(String conn) {
        connections.add(conn);
        System.out.println("Released connection: " + conn);
    }
 
    public synchronized int getAvailableCount() {
        return connections.size();
    }
}
 
// Sử dụng trong bất kỳ service nào
DatabasePool pool = DatabasePool.getInstance();
String conn = pool.getConnection();
// ... sử dụng connection ...
pool.releaseConnection(conn);

// Xấu — UserService lấy database từ đâu?
class UserService {
  createUser(name: string): void {
    // Phụ thuộc ẩn — không thể biết nếu không đọc code
    const db = DatabasePool.getInstance();
    db.query(`INSERT INTO users (name) VALUES ('${name}')`);
  }
}
 
// Tốt — Dependencies tường minh
class UserService {
  constructor(private db: DatabasePool) {}
 
  createUser(name: string): void {
    this.db.query(`INSERT INTO users (name) VALUES ('${name}')`);
  }
}

// Module A thay đổi config
AppConfig.getInstance().set("timeout", "5000");
 
// Module B đọc config sau — bị ảnh hưởng bởi Module A
const timeout = AppConfig.getInstance().get("timeout");
// Là "5000"? Giá trị mặc định? Ai biết nếu không trace mọi lần gọi?

// Test 1: Thêm entries vào logger
test("should log messages", () => {
  const logger = Logger.getInstance();
  logger.log("test message");
  expect(logger.getLogs()).toHaveLength(1); // ✅ Pass
});
 
// Test 2: Mong đợi logger mới — nhưng nhận state của Test 1!
test("should start with empty logs", () => {
  const logger = Logger.getInstance();
  expect(logger.getLogs()).toHaveLength(0); // ❌ FAIL — có 1 entry từ Test 1
});

class Logger {
  private static instance: Logger;
  private logs: string[] = [];
 
  private constructor() {}
 
  public static getInstance(): Logger {
    if (!Logger.instance) {
      Logger.instance = new Logger();
    }
    return Logger.instance;
  }
 
  public log(message: string): void {
    this.logs.push(`[${new Date().toISOString()}] ${message}`);
  }
 
  public getLogs(): string[] {
    return [...this.logs];
  }
 
  // Chỉ cho testing — cho phép reset state giữa các test
  public static resetInstance(): void {
    Logger.instance = undefined as unknown as Logger;
  }
}
 
// Trong tests
afterEach(() => {
  Logger.resetInstance();
});

// Định nghĩa interface
interface ILogger {
  log(message: string): void;
  getLogs(): string[];
}
 
// Singleton implement interface
class Logger implements ILogger {
  private static instance: Logger;
  private logs: string[] = [];
 
  private constructor() {}
 
  public static getInstance(): Logger {
    if (!Logger.instance) {
      Logger.instance = new Logger();
    }
    return Logger.instance;
  }
 
  public log(message: string): void {
    this.logs.push(`[${new Date().toISOString()}] ${message}`);
  }
 
  public getLogs(): string[] {
    return [...this.logs];
  }
}
 
// Service phụ thuộc vào interface, không phải Singleton
class OrderService {
  constructor(private logger: ILogger) {}
 
  placeOrder(item: string): void {
    this.logger.log(`Order placed: ${item}`);
  }
}
 
// Production — inject Singleton
const orderService = new OrderService(Logger.getInstance());
 
// Testing — inject mock
class MockLogger implements ILogger {
  public messages: string[] = [];
 
  log(message: string): void {
    this.messages.push(message);
  }
 
  getLogs(): string[] {
    return this.messages;
  }
}
 
test("should log when order is placed", () => {
  const mockLogger = new MockLogger();
  const service = new OrderService(mockLogger);
 
  service.placeOrder("Laptop");
 
  expect(mockLogger.messages).toHaveLength(1);
  expect(mockLogger.messages[0]).toContain("Laptop");
});

# Python - Dependency Injection với Singleton
from abc import ABC, abstractmethod
 
 
class ILogger(ABC):
    @abstractmethod
    def log(self, message: str) -> None: ...
 
    @abstractmethod
    def get_logs(self) -> list[str]: ...
 
 
class Logger(ILogger):
    _instance = None
 
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance._logs = []
        return cls._instance
 
    def log(self, message: str) -> None:
        self._logs.append(message)
 
    def get_logs(self) -> list[str]:
        return self._logs.copy()
 
 
class OrderService:
    def __init__(self, logger: ILogger):
        self._logger = logger
 
    def place_order(self, item: str) -> None:
        self._logger.log(f"Order placed: {item}")
 
 
# Production
service = OrderService(Logger())
 
# Testing
class MockLogger(ILogger):
    def __init__(self):
        self.messages: list[str] = []
 
    def log(self, message: str) -> None:
        self.messages.append(message)
 
    def get_logs(self) -> list[str]:
        return self.messages
 
 
def test_place_order():
    mock = MockLogger()
    service = OrderService(mock)
    service.place_order("Laptop")
    assert len(mock.messages) == 1
    assert "Laptop" in mock.messages[0]

// Java - Dependency Injection với Singleton
public interface ILogger {
    void log(String message);
    List<String> getLogs();
}
 
public class Logger implements ILogger {
    private static class Holder {
        private static final Logger INSTANCE = new Logger();
    }
 
    private final List<String> logs = new ArrayList<>();
    private Logger() {}
 
    public static Logger getInstance() {
        return Holder.INSTANCE;
    }
 
    @Override
    public void log(String message) {
        logs.add("[" + java.time.Instant.now() + "] " + message);
    }
 
    @Override
    public List<String> getLogs() {
        return List.copyOf(logs);
    }
}
 
public class OrderService {
    private final ILogger logger;
 
    // Inject dependency — không gắn với Logger.getInstance()
    public OrderService(ILogger logger) {
        this.logger = logger;
    }
 
    public void placeOrder(String item) {
        logger.log("Order placed: " + item);
    }
}
 
// Production
OrderService service = new OrderService(Logger.getInstance());
 
// Testing
ILogger mockLogger = mock(ILogger.class);
OrderService testService = new OrderService(mockLogger);
testService.placeOrder("Laptop");
verify(mockLogger).log(contains("Laptop"));