单例模式

Posted 2021-03-02 saints

应用场景

业务概念上只适合在系统中保留一份的数据，比如系统的配置信息类适合设计为单例模式，还可以使用单例模式解决多个实例访问资源冲突的问题。

实现

饿汉式

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

        }

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

懒汉式

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

        }

        public static Singleton GetInstance()
        {
            lock (lockObj)
            {
                if (instance==null)
                {
                    instance = new Singleton();
                }
            }
            return instance;
        }

    }

双重检测

    public class Singleton
    {
        static Singleton instance = null;

        static readonly object lockObj = new object();
        private Singleton()
        {

        }

        public static Singleton GetInstance()
        {
            if (instance==null)
            {
                lock (lockObj)
                {
                    if (instance==null)
                    {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }

    }

内部静态类

    public class Singleton
    {
        private Singleton()
        {

        }

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

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

实现对比

1. 饿汉式，在类加载期间就已经将instance静态类初始化好，所以instance实例的创建时线程安全的。不过饿汉式不支持延迟加载。

2. 懒汉式，支持延迟加载，但是会导致频繁加锁、释放锁，以及并发度低的问题，频繁调用会产生性能瓶颈

3. 双重检测，既支持延迟加载，又支持高并发。只要instance实例被创建之后，再调用GetInstance方法都不会进入到加锁的逻辑中。之所以会检查两次instance是否为null，是因为install为null，时，可能会有两个或者多个线程同时通过第一层检查，在一个线程创建完instance实例后，其他线程进入lock之内，不检查instance会再次创建实例。

4. 内部静态类，既支持延迟加载，又支持高并发。延迟加载体现在外部单例类被加载时，并不会创建内部静态类，只有在调用GetInstance方法时，内部类才会被加载，这时才创建instance，内部静态类的实现比双重检测简单。