What is the Singleton design pattern in Java? Implement it thread-safely.

public class DatabaseConnection {
    private static DatabaseConnection instance;

    private DatabaseConnection() {
        System.out.println("Connecting to database...");
    }

    public static DatabaseConnection getInstance() {
        if (instance == null) {
            instance = new DatabaseConnection();  // ⚠️ Not thread-safe
        }
        return instance;
    }
}

public class DatabaseConnection {
    private static DatabaseConnection instance;

    private DatabaseConnection() {}

    public static synchronized DatabaseConnection getInstance() {
        if (instance == null) {
            instance = new DatabaseConnection();
        }
        return instance;
    }
    // Problem: synchronized on every call — performance overhead
}

public class DatabaseConnection {
    // volatile ensures visibility across threads
    private static volatile DatabaseConnection instance;

    private DatabaseConnection() {}

    public static DatabaseConnection getInstance() {
        if (instance == null) {                  // First check (no lock)
            synchronized (DatabaseConnection.class) {
                if (instance == null) {          // Second check (with lock)
                    instance = new DatabaseConnection();
                }
            }
        }
        return instance;
    }
}

public enum WebDriverManager {
    INSTANCE;

    private WebDriver driver;

    public WebDriver getDriver() {
        if (driver == null) {
            driver = new ChromeDriver();
        }
        return driver;
    }

    public void quitDriver() {
        if (driver != null) {
            driver.quit();
            driver = null;
        }
    }
}

// Usage
WebDriver driver = WebDriverManager.INSTANCE.getDriver();

public class ConfigManager {
    private final Properties properties;

    private ConfigManager() {
        properties = new Properties();
        try {
            properties.load(new FileInputStream("config.properties"));
        } catch (IOException e) {
            throw new RuntimeException("Config not found", e);
        }
    }

    // Inner class — loaded only when first accessed
    private static class Holder {
        static final ConfigManager INSTANCE = new ConfigManager();
    }

    public static ConfigManager getInstance() {
        return Holder.INSTANCE;  // thread-safe without synchronized
    }

    public String get(String key) {
        return properties.getProperty(key);
    }
}

// WebDriver Singleton — one browser per test class
public class BrowserFactory {
    private static volatile WebDriver driver;

    private BrowserFactory() {}

    public static WebDriver getDriver() {
        if (driver == null) {
            synchronized (BrowserFactory.class) {
                if (driver == null) {
                    WebDriverManager.chromedriver().setup();
                    driver = new ChromeDriver();
                    driver.manage().window().maximize();
                }
            }
        }
        return driver;
    }

    public static void quitDriver() {
        if (driver != null) {
            driver.quit();
            driver = null;
        }
    }
}

// Any test can call
WebDriver driver = BrowserFactory.getDriver();

// Reflection can break singleton:
Constructor<Singleton> c = Singleton.class.getDeclaredConstructor();
c.setAccessible(true);
Singleton s2 = c.newInstance();  // breaks singleton!

// Prevention — throw exception in constructor if instance exists
private Singleton() {
    if (instance != null) {
        throw new RuntimeException("Use getInstance()");
    }
}
// Or use Enum — reflection-proof