Singleton Pattern in Java: Thread-Safe Implementation Guide

// ❌ BROKEN: This singleton is NOT thread-safe.
// Two threads can both pass the null check before either sets the field.

public class BrokenSingleton {

    // The one instance — starts as null until first requested
    private static BrokenSingleton instance;

    // Private constructor prevents anyone outside this class calling `new BrokenSingleton()`
    private BrokenSingleton() {
        System.out.println("BrokenSingleton created by thread: " + Thread.currentThread().getName());
    }

    // ❌ No synchronization — race condition lives here
    public static BrokenSingleton getInstance() {
        if (instance == null) {               // Thread A and Thread B can BOTH pass this check
            instance = new BrokenSingleton(); // ...and BOTH create an instance
        }
        return instance;
    }

    public static void main(String[] args) throws InterruptedException {
        // Spin up 5 threads all trying to grab the instance at the same time
        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(() -> {
                BrokenSingleton singleton = BrokenSingleton.getInstance();
                System.out.println("Got instance with hashCode: " + singleton.hashCode());
            });
            thread.start();
        }
    }
}

// ✅ CORRECT: Double-Checked Locking Singleton — thread-safe and performant
// Real-world use case: Application-wide configuration manager

public class ThreadSafeSingleton {

    // `volatile` is NON-NEGOTIABLE here — it prevents the JVM from publishing
    // a half-constructed object to other threads due to instruction reordering
    private static volatile ThreadSafeSingleton instance;

    private final String configFilePath;
    private final int maxConnections;

    // Private constructor loads config once — expensive operation done only once
    private ThreadSafeSingleton() {
        System.out.println("[CONFIG] Loading configuration... (thread: "
                + Thread.currentThread().getName() + ")");
        this.configFilePath = "/etc/myapp/config.yaml"; // simulate reading from disk
        this.maxConnections = 50;
    }

    public static ThreadSafeSingleton getInstance() {
        // FIRST check (no lock): if instance already exists, return immediately — fast path
        if (instance == null) {

            // Only one thread can enter this block at a time
            synchronized (ThreadSafeSingleton.class) {

                // SECOND check (inside lock): another thread may have created
                // the instance while we were waiting to acquire the lock
                if (instance == null) {
                    instance = new ThreadSafeSingleton();
                }
            }
        }
        return instance; // returns the same object every single time after creation
    }

    public String getConfigFilePath() { return configFilePath; }
    public int getMaxConnections()    { return maxConnections; }

    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> {
            ThreadSafeSingleton config = ThreadSafeSingleton.getInstance();
            System.out.println(Thread.currentThread().getName()
                    + " -> hashCode: " + config.hashCode()
                    + ", maxConnections: " + config.getMaxConnections());
        };

        // Launch 6 threads simultaneously — only ONE constructor call should happen
        Thread[] threads = new Thread[6];
        for (int i = 0; i < 6; i++) {
            threads[i] = new Thread(task, "Worker-" + i);
        }
        for (Thread t : threads) t.start();
        for (Thread t : threads) t.join(); // wait for all threads to finish
    }
}

// ✅ BULLETPROOF: Enum Singleton — reflection-safe, serialization-safe, thread-safe
// Real-world use case: Application event bus or centralized audit logger

public enum EnumSingleton {

    // This is the single instance — the JVM creates it exactly once, guaranteed
    INSTANCE;

    private int eventCount = 0;
    private final String logPrefix = "[AUDIT]";

    // Your actual business methods go here — treat INSTANCE like a regular object
    public void logEvent(String eventDescription) {
        eventCount++;
        System.out.println(logPrefix + " Event #" + eventCount
                + " | " + eventDescription
                + " | Logged by: " + Thread.currentThread().getName());
    }

    public int getTotalEventCount() {
        return eventCount;
    }

    public static void main(String[] args) throws Exception {
        // Normal usage — call via INSTANCE
        EnumSingleton.INSTANCE.logEvent("User login: alice@example.com");
        EnumSingleton.INSTANCE.logEvent("File uploaded: report_q3.pdf");

        // Try to break it with reflection — the JVM will throw an exception
        try {
            java.lang.reflect.Constructor<EnumSingleton> constructor =
                    EnumSingleton.class.getDeclaredConstructor(String.class, int.class);
            constructor.setAccessible(true);
            EnumSingleton hackedInstance = constructor.newInstance("FAKE", 0); // ❌ This will fail
        } catch (Exception e) {
            // JVM protects enum — reflection attack is blocked
            System.out.println("Reflection attack blocked: " + e.getClass().getSimpleName());
        }

        System.out.println("Total events logged: " + EnumSingleton.INSTANCE.getTotalEventCount());
        System.out.println("Instance hashCode: " + EnumSingleton.INSTANCE.hashCode());
    }
}

// Demonstrating real Singletons already in the Java standard library

public class RealWorldSingletonDemo {

    public static void main(String[] args) {

        // --- 1. Runtime Singleton ---
        // Runtime.getRuntime() always returns the same Runtime object
        Runtime jvmRuntime = Runtime.getRuntime();
        System.out.println("Available processors: " + jvmRuntime.availableProcessors());
        System.out.println("Max JVM memory (bytes): " + jvmRuntime.maxMemory());

        // Calling it again returns the SAME instance — same hashCode
        Runtime anotherReference = Runtime.getRuntime();
        System.out.println("Same Runtime instance? " + (jvmRuntime == anotherReference)); // true

        // --- 2. Bill Pugh Holder Idiom (elegant lazy singleton, no synchronization needed) ---
        // The inner class is only loaded when getInstance() is first called
        DatabaseConnectionPool pool1 = DatabaseConnectionPool.getInstance();
        DatabaseConnectionPool pool2 = DatabaseConnectionPool.getInstance();
        System.out.println("Same pool instance? " + (pool1 == pool2)); // true
        pool1.executeQuery("SELECT * FROM users WHERE active = true");
    }
}

// Bill Pugh Initialization-on-Demand Holder — clean, lazy, thread-safe without volatile or synchronized
class DatabaseConnectionPool {

    private final int poolSize;

    private DatabaseConnectionPool() {
        this.poolSize = 10;
        System.out.println("[DB POOL] Connection pool initialized with " + poolSize + " connections.");
    }

    // The JVM only loads this inner class when getInstance() is first called
    // Class loading in Java is thread-safe — no extra synchronization needed
    private static final class PoolHolder {
        private static final DatabaseConnectionPool POOL_INSTANCE = new DatabaseConnectionPool();
    }

    public static DatabaseConnectionPool getInstance() {
        return PoolHolder.POOL_INSTANCE; // inner class loaded here on first call
    }

    public void executeQuery(String sql) {
        System.out.println("[DB POOL] Executing on pool (size=" + poolSize + "): " + sql);
    }
}