Analysis of singleton pattern and common writing methods (design pattern 01)

Ensure that a class has only one instance and provide a global access point to the instance.

——"Design Pattern"

The concept of singleton pattern is very simple. Below is C# Using language as an example, the advantages and disadvantages of common singleton writing methods are listed.

1. Simple implementation

 public sealed class Singleton
    {
        static Singleton instance = null;

        public void Show()
        {
            Console.WriteLine(  "instance function");
        }
        private Singleton()
        {
        }

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

Comments:

            Not safe for threads
Requirements have been met in single thread
Advantages:
Since the instance is created inside the Instance property method , so the class can use additional functionality
and not perform instantiation until the object requires an instance; this approach is called "lazy instantiation". Lazy instantiation avoids unnecessary instantiation of singletons when the application starts.

2. Thread safety

public sealed class Singleton
    {
        static Singleton instance = null;
        private static readonly object padlock = new object();

        private Singleton()
        {
        }

        public static Singleton Instance
        {
            get
            {
                lock (padlock)
                {
                    if (instance == null)
                    {
                        instance = new Singleton();
                    }
                }

                return instance;
            }
        }
    }

Comment:

The only part of the program that is locked at the same time is A thread can enter
The object instance is created by the thread that enters first
Later threads will be false when entering (instance == null) and will not be returned To create object instances
Added additional overhead and lost performance

##3. Double lock

 public sealed class Singleton
    {
        static Singleton instance = null;
        private static readonly object padlock = new object();

        private Singleton()
        {
        }

        public static Singleton Instance
        {
            get
            {
                if (instance == null)
                {
                    lock (padlock)
                    {
                        if (instance == null)
                        {
                            instance = new Singleton();
                        }
                    }
                }
                return instance;
            }
        }
    }

Comment:

Multi-thread safety
Threads are not locked every time
Allow instantiation to be delayed until the first time the object is accessed

4. Static initialization

 public sealed class Singleton
    {
        private static readonly Singleton instance = null;
        static Singleton()
        {
            instance = new Singleton();
        }
        private Singleton()
        {
        }
        public static Singleton Instance
        {
            get
            {
                return instance;
            }
        }
    }

Comment:

Depends on the common language runtime to handle variable initialization
Public static properties provide a Global access point
Less control over the instantiation mechanism (implemented by .NET)
Static initialization is the preferred method to implement Singleton in .NET

Small Note:

# Static constructors have neither access modifiers, C# will automatically mark them as private, why they must be marked For private,

is to prevent code written by developers from calling it. The call to it is always the responsibility of the CLR.

##5. Delayed initialization

public sealed class Singleton
    {
        private Singleton()
        {
        }
        public static Singleton Instance
        {
            get
            {
                return Nested.instance;
            }
        }

        public static void Hello()
        {
        }

        private class Nested
        {
            internal static readonly Singleton instance = null;
            static Nested()
            {
                instance = new Singleton();
            }
        }
    }

Comments:

The initialization work is done by the Nested class This is done with a static member, thus achieving lazy initialization.

Because the timing of calling static functions is when the class is instantiated or the static member is called, And the .net framework calls the static constructor to initialize the static member variables, So, if you write according to the fourth method, When the Hello method is called again, a Singleton instance will be instantiated. This is not what we want to see, because we may just want to use the Hello method and nothing else.

Notes:

1. The instance constructor in Singleton mode can be set to protected to allow subclasses to be derived.
2. Singleton mode generally does not support the ICloneable interface, because this may lead to multiple object instances, which is contrary to the original intention of Singleton mode.
3. Singleton mode generally does not support serialization, because this may also lead to multiple object instances, which is also contrary to the original intention of Singleton mode.
4. The Singletom mode only takes into account the management of object creation, but does not consider the management of object destruction. In terms of platforms that support garbage collection and the overhead of objects, we generally do not need to perform special management of their destruction.

##Summary:

1. Singleton Patterns limit rather than improve class creation.
2. The core of understanding and extending the Singleton pattern is "how to control the user's arbitrary call to the constructor of a class using new."
3. You can easily modify a Singleton to have a few instances. This is allowed and meaningful.

The above is the content of singleton pattern and common writing method analysis (design pattern 01), more related Please pay attention to the PHP Chinese website (www.php.cn) for content!