C#设计模式——单例模式的实现

1. 什么是单例

保证一个类只有一个实例的实现方法。

2. 使用场景

页面访问计数器

需要保持状态的工具类

需求很多，不能一一列举了

3. 实现方

非线程安全

    /// <summary>
    /// 单例模式的实现
    /// </summary>
    public sealed class Singleton
    {
        //定义一个静态变量来保存类的实例
        private static Singleton _instance = null;

        //定义私有构造函数，使外界不能创建该类实例
        private Singleton()
        {
        }
        /// <summary>
        /// 定义公有方法提供一个全局访问点,同时你也可以定义公有属性来提供全局访问点
        /// </summary>
        /// <returns></returns>
        public static Singleton Instance()
        {
            //如果类的实例不存在则创建，否则直接返回
            if (_instance == null)
            {
                _instance = new Singleton();
            }
            return _instance;
        }
    }

上面的单例模式的实现在单线程下确实是可以的，但是在多线程环境下会存在两个线程同时执行if (instance == null)并且创建两个不同的实例

简单线程安全

    /// <summary>
    /// 单例模式的实现
    /// </summary>
    public sealed class Singleton
    {
        // 定义一个静态变量来保存类的实例
        private static Singleton instance = null;

        // 定义一个标识确保线程同步
        private static readonly object padlock = new object();

        Singleton()
        {
        }

        public static Singleton Instance()
        {
            // 当第一个线程运行到这里时，此时会对locker对象 "加锁"，
            // 当第二个线程运行该方法时，首先检测到locker对象为"加锁"状态，该线程就会挂起等待第一个线程解锁
            // lock语句运行完之后（即线程运行完之后）会对该对象"解锁"
            lock (padlock)
            {
                // 如果类的实例不存在则创建，否则直接返回
                if (instance == null)
                {
                    instance = new Singleton();
                }
            }
            return instance;
        }
    }

上面的例子解决了多线程的问题,但是每个线程调用Instance()都会使用到锁，而调用锁的开销较大，这个实现会有一定的性能损失。

双重验证线程安全

    /// <summary>
    /// 单例模式的实现
    /// </summary>
    public sealed class Singleton
    {
        // 定义一个静态变量来保存类的实例
        private static Singleton instance = null;

        // 定义一个标识确保线程同步
        private static readonly object padlock = new object();

        Singleton()
        {
        }

        public static Singleton Instance()
        {
            // 当第一个线程运行到这里时，此时会对locker对象 "加锁"，
            // 当第二个线程运行该方法时，首先检测到locker对象为"加锁"状态，该线程就会挂起等待第一个线程解锁
            // lock语句运行完之后（即线程运行完之后）会对该对象"解锁"
            if (instance == null)
            {
                lock (padlock)
                {
                    // 如果类的实例不存在则创建，否则直接返回
                    if (instance == null)
                    {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }

上面的例子在保证线程安全的同时提高了性能

静态变量实现单例

    /// <summary>
    /// 单例模式的实现
    /// </summary>
    public sealed class Singleton
    {
        //在Singleton第一次被调用时会执行instance的初始化
        private static readonly Singleton instance = new Singleton();

        private Singleton()
        {
        }

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

上面的例子利用.net的特性来完成单例模式的创建，也是线程安全的

4. 优点

在内存中只有一个对象，节省内存空间；

避免频繁的创建销毁对象，可以提高性能；

避免对共享资源的多重占用，简化访问；

为整个系统提供一个全局访问点。