Java中的單例設計模式是什麼？

單例設計模式在Java中通過私有構造器和靜態方法確保一個類只有一個實例並提供全局訪問點，適用於控制共享資源的訪問。實現方式包括：1. 懶加載，即首次請求時才創建實例，適用於資源消耗大且不一定需要的情況；2. 線程安全處理，通過同步方法或雙重檢查鎖定確保多線程環境下只創建一個實例，並減少性能影響；3. 餓漢式加載，在類加載時直接初始化實例，適合輕量級對像或可接受提前初始化的場景；4. 枚舉實現，利用Java枚舉天然支持序列化、線程安全及防止反射攻擊的特性，是推薦的簡潔可靠方式。不同實現方式可根據具體需求選擇以滿足性能與安全性要求。

A singleton design pattern in Java ensures that a class has only one instance and provides a global point of access to it. This is useful when you want to control access to shared resources, like configuration settings or connection pools.

Here's how it works and how you can implement it effectively.

Lazy Initialization – Create the Instance When Needed

Lazy initialization means the singleton instance is created only when it's first requested, not when the class loads. This can be helpful if creating the instance is resource-intensive and might not always be needed.

Here's a basic example:

 public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

• The constructor is private so no other class can instantiate it.
• The getInstance() method controls access to the single instance.
• This version isn't thread-safe — more on that next.

Use this approach when startup performance matters and the instance isn't always needed.

Thread-Safety – Make It Work Across Multiple Threads

If multiple threads call getInstance() at the same time, the basic lazy version might create multiple instances. To fix that, you can make the method synchronized:

 public static synchronized Singleton getInstance() {
    if (instance == null) {
        instance = new Singleton();
    }
    return instance;
}

But synchronizing the whole method can hurt performance. A better alternative is double-checked locking :

 private static volatile Singleton instance;

public static Singleton getInstance() {
    if (instance == null) {
        synchronized (Singleton.class) {
            if (instance == null) {
                instance = new Singleton();
            }
        }
    }
    return instance;
}

• Using volatile ensures visibility across threads.
• Double-checking avoids unnecessary synchronization after the instance is created.

This version gives you thread safety with minimal performance impact.

Eager Initialization – Create the Instance Upfront

If you know the instance will always be needed, you can create it when the class loads:

 public class Singleton {
    private static final Singleton INSTANCE = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return INSTANCE;
    }
}

• Simpler and thread-safe without needing synchronization.
• Best for lightweight objects or when early creation is acceptable.

This is often the easiest way to implement a singleton if lazy loading isn't required.

Enum-Based Singleton – Cleanest and Safe Approach

Java enums provide a simple and effective way to implement singletons:

 public enum Singleton {
    INSTANCE;

    public void doSomething() {
        // method implementation
    }
}

• Enums are inherently serializable and thread-safe.
• Prevents reflection-based attacks that could create multiple instances.
• Simple syntax and safe by default.

If you're using Java 1.5 or later, this is generally the most robust option.

That's the core of how singletons work in Java — different methods suit different needs, but they all aim to enforce a single instance across your app.

以上是Java中的單例設計模式是什麼？的詳細內容。更多資訊請關注PHP中文網其他相關文章！