Singleton pattern is used to ensure that a class has only one instance and provides a global access point. 1. Prevent external instance creation through private constructors. 2. Create a static private instance inside the class. 3. Provide a public static method to obtain the instance. Implementation needs to pay attention to thread safety, such as using double check locking or static internal classes. Advantages include resource saving and unified management, while disadvantages are high coupling, dependency hiding, and complex multi-threading.

The Singleton pattern is a common software design pattern. Its core purpose is to ensure that only one instance of a class exists in the entire application and provide a global access point to obtain this instance. This is very useful when managing shared resources (such as database connections, configuration information, loggers, etc.).

Why do you need a Singleton?

You might ask: Why should you restrict a class to have only one instance? In fact, in many scenarios, we hope that some objects will appear only once in the entire system. For example:

• Database connection pool: Usually only one connection pool is needed to manage all connections.
• Configuration Manager: The application's configuration information needs to be loaded only once.
• Logger: Multiple instances can cause log confusion.

If a new object is created every call, it will not only waste resources, but it may also lead to inconsistent states. Singleton is used to solve this kind of problem.

How to implement a basic Singleton?

To implement Singleton, the key is to control the instantiation process of the class. Generally speaking, there are several steps:

• The constructor is privatized to prevent external instances from being created through new .
• Create a static private instance inside the class.
• A publicly disclosed static method is provided for obtaining the instance.

Let's give a simple Java example:

 public class Logger {
    private static Logger instance;

    private Logger() {}

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

In this way, no matter who calls Logger.getInstance() , he will get the same instance.

Note: The above example is not thread-safe. Locking may be required or a double check mechanism may be used in a multi-threaded environment.

Thread-safe implementation

If your application is multi-threaded, you should consider how to ensure that getInstance() is thread-safe. Common practices include:

• Using synchronization method (poor performance)
• Lock with double check (recommended)
• Using static internal classes (simple and efficient)

Take the double check as an example:

 public class Logger {
    private static volatile Logger instance;

    private Logger() {}

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

Two judgments and synchronized locks are used here to avoid locking each time and improve efficiency.

A brief analysis of the advantages and disadvantages of singletons

advantage:

• Save memory and resource overhead and avoid repeated initialization.
• Provides a unified access portal for convenient centralized management.

shortcoming:

• Overuse will lead to high code coupling, which is not conducive to testing.
• Possibly hide dependencies between classes.
• Multi-threading requires additional thread safety issues.

Basically that's it. The Singleton mode seems simple, but if you want to use it well in different scenarios, you still have to pay attention to the details.

The above is the detailed content of What is the Singleton pattern?. For more information, please follow other related articles on the PHP Chinese website!