Thread safety solution of singleton mode in concurrent environment

Thread safety solution of singleton mode in concurrent environment

In the process of software development, the singleton mode is widely used to ensure that a certain class only has In an instance scenario. However, in a concurrent environment, the singleton pattern may lead to thread safety issues. This article will introduce some common solutions to ensure the thread safety of the singleton pattern in a concurrent environment, and provide corresponding code examples.

1. Double-Checked Locking

Lazy style means that the singleton class is instantiated only when the singleton class is used for the first time. This method can avoid double-checked locking when the application starts. Create singleton instances whenever needed to improve application performance. However, in a multi-threaded environment, laziness may cause problems with multiple threads entering the instantiation code block at the same time.

In order to solve this problem, you can use the double-checked locking mechanism, namely Double-Checked Locking. Before instantiating the code block, use the synchronized keyword to synchronize the static methods of the class to ensure that only one thread can enter the instantiation code block. Additionally, a second check is done within the synchronized code block to ensure that no other thread has created an instance while waiting for the lock.

The following is a sample code for a singleton class using lazy and double-checked locking mechanisms:

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {
    }

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

In the above code, the instance variable declared as volatile is used to ensure that the variable is valid for all Thread visibility. The double-check locking mechanism ensures that only one thread can enter the instantiation code block, thus solving the thread safety problem of lazy people in concurrent environments.

2. Hungry Chinese style

Hungry Chinese style refers to realizing the singleton mode by creating an instance when the class is initialized. This method is thread-safe in a multi-threaded environment, because when the class is initialized, the JVM will ensure that only one thread can initialize the class.

The following is a sample code for a singleton class using Hungry style:

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

    private Singleton() {
    }

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

In the above code, the instance variable is declared as final, ensuring that it can only be assigned once. By initializing the instance in a static code block, you can ensure that the singleton instance is created when the class is loaded.

3. Internal static class

Internal static class refers to delaying the creation of a singleton instance until the first time the instance is used, while using the class loading mechanism to ensure thread safety. This method not only achieves lazy loading, but also ensures thread safety.

The following is a sample code for a singleton class using an internal static class:

public class Singleton {
    private static class SingletonHolder {
        private static final Singleton instance = new Singleton();
    }

    private Singleton() {
    }

    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }
}

In the above code, the SingletonHolder class is declared as private, and is only referenced in the getInstance method of the Singleton class class will be loaded. Since the class loader is thread-safe during the process of loading the class, the thread safety of SingletonHolder can be guaranteed.

Summary:

This article introduces the thread safety solution of the singleton mode in a concurrent environment and provides corresponding code examples. The lazy style avoids the problem of multiple threads entering the instantiation code block at the same time through the double-check locking mechanism. The hungry style ensures thread safety through class initialization, and the internal static class combines lazy loading and thread safety. Based on actual needs and usage scenarios, choosing a suitable thread-safety solution can improve the efficiency and stability of the singleton mode in a concurrent environment.

The above is the detailed content of Thread safety solution of singleton mode in concurrent environment. For more information, please follow other related articles on the PHP Chinese website!