All 15 Design Patterns in Java questions
More in Design Patterns in Java
What is the Factory Method pattern's simplest form -- a basic static factory returning different subtype instances based on input -- and why might you prefer it over exposing constructors directly? How does the Builder pattern solve the "telescoping constructor" problem, and how would you implement it for a class with many optional parameters? What is the Strategy pattern, and how do Java 8's functional interfaces and lambdas make implementing it significantly more concise than the traditional interface-plus-implementation-classes approach? What is the Factory Method pattern, and how does it differ from the simpler Static Factory Method idiom (like List.of() or Optional.of())? What is the Adapter pattern, and when would you use it to make an existing class compatible with an interface it wasn't originally designed to implement? What is the Template Method pattern, and how is it used to define the skeleton of an algorithm while letting subclasses customize specific steps? What is the difference between composition and inheritance as ways to reuse code, and why does the design principle "favor composition over inheritance" generally guide modern Java design (including many design patterns themselves)? How would you implement the Composite pattern to treat individual objects and groups of objects uniformly, such as a file system with files and directories? How would you implement the Observer pattern in Java, and how does it compare to using the built-in PropertyChangeSupport or a reactive streams library? How would you implement the Decorator pattern in Java, and how does java.io's InputStream/OutputStream class hierarchy exemplify this pattern in the JDK itself?
Advertisement
Back to results for “OOP & Classes”
Java › Design Patterns in Java

What is the Singleton pattern, and how would you implement a thread-safe Singleton in Java?

Beginner

Answer

Singleton ensures a class has exactly one instance and provides a global access point to it -- the enum-based approach is generally considered the simplest, safest way to implement it in Java (inherently thread-safe, serialization-safe, and immune to reflection-based instantiation attacks that can break other approaches), though the classic double-checked-locking lazy initialization pattern (using a volatile field) remains common for scenarios not suited to enum.
public enum ConfigManager {
    INSTANCE;

    private final Map<String, String> settings = new HashMap<>();

    public String get(String key) { return settings.get(key); }
}

// Usage
ConfigManager.INSTANCE.get("apiUrl");
Real-world example An application-wide configuration manager is implemented as an enum-based Singleton, guaranteeing exactly one instance exists across the entire application regardless of how many places reference ConfigManager.INSTANCE, with the JVM itself enforcing this guarantee rather than relying on manual synchronization logic.

Common follow-ups: Why is the enum-based Singleton considered immune to reflection-based attacks that can break the classic private-constructor approach?;What are the criticisms of Singleton as an anti-pattern, particularly regarding testability?

Concurrency & Threads;OOP & Classes
All 15 Design Patterns in Java questions