第九节：单例模式详解

一. 单例模式

1. 背景

　   在有些系统中，为了节省内存资源、保证数据内容的一致性，对某些类要求只能创建一个实例，这就是所谓的单例模式。

　   在计算机系统中，还有 Windows 的回收站、操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用程序的日志对象、数据库的连接池、网站的计数器、Web 应用的配置对象、应用程序中的对话框、系统中的缓存等常常被设计成单例。

2. 定义和特点

(1). 定义

　指一个类只有一个实例，且该类能自行创建这个实例的一种模式。

　例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。

(2). 特点

　A. 单例类只有一个实例对象；

　B. 该单例对象必须由单例类自行创建；外部不能通过new来创建。

　C. 单例类对外提供一个访问该单例的全局访问点；

3. 具体实现

(1). 模式结构

 　  单例模式中最简单的模式之一。通常，普通类的构造函数是公有的，外部类可以通过“new 构造函数()”来生成多个实例。但是，如果将类的构造函数设为私有的，外部类就无法调用该构造函数，也就无法生成多个实例。这时该类自身必须定义一个静态私有实例，并向外提供一个静态的公有函数用于创建或获取该静态私有实例。

单例类有这么集中写法：

　A. 懒汉模式： 双if+lock锁
　B. 饿汉模式： 静态构造函数、 静态变量。

需要注意的：

　A. private static Singleton _Singleton = null;  该静态对象不会被回收，会常驻内存。

　B. 单例只保证了实例的唯一，并不能保证实例中的方法或变量也唯一，所以单例中的方法或变量，在多线程面前，仍然可能是不安全的。

(2). 具体实现

A. 饿汉模式-静态构造函数

    /// <summary>
    /// 饿汉模式(利用静态构造函数)
    /// 是线程安全的
    /// </summary>
    public class HungrySingleton1
    {
        /// <summary>
        /// private 避免类在外部被实例化
        /// </summary>
        private HungrySingleton1()
        {
            //模拟耗时操作
            Thread.Sleep(2000);
            Console.WriteLine("HungrySingleton1被创建成功了");
        }
        private static HungrySingleton1 _hungrySingleton = null;
        /// <summary>
        /// 静态的构造函数：只能有一个，且是无参数的.
        /// 由CLR保证，只有在程序第一次使用该类之前被调用，而且只能调用一次
        /// </summary>
        static HungrySingleton1()
        {
            _hungrySingleton = new HungrySingleton1();
        }
        /// <summary>
        /// 获取该对象（对外开放）
        /// </summary>
        /// <returns></returns>
        public static HungrySingleton1 CreateIntance()
        {
            return _hungrySingleton;
        }
    }

B. 饿汉模式-静态变量

    /// <summary>
    /// 饿汉模式(利用静态变量)
    /// 是线程安全的
    /// </summary>
    public class HungrySingleton2
    {
        /// <summary>
        /// private 避免类在外部被实例化
        /// </summary>
        private HungrySingleton2()
        {
            //模拟耗时操作
            Thread.Sleep(2000);
            Console.WriteLine("HungrySingleton2被创建成功了");
        }
        /// <summary>
        /// 静态变量：由CLR保证，在程序第一次使用该类之前被调用，而且只调用一次
        /// </summary>
        private static HungrySingleton2 _hungrySingleton = new HungrySingleton2();
        /// <summary>
        /// 获取该对象（对外开放）
        /// </summary>
        /// <returns></returns>
        public static HungrySingleton2 CreateIntance()
        {
            return _hungrySingleton;
        }
    }

C. 懒汉模式

  /// <summary>
    /// 懒汉模式
    /// </summary>
    public class LazySingleton
    {
        /// <summary>
        ///  private 避免类在外部被实例化
        /// </summary>
        private LazySingleton()
        {
            //模拟耗时操作
            Thread.Sleep(2000);
            Console.WriteLine("LazySingleton被创建成功了");
        }

        private static LazySingleton _instance = null;
        //线程锁
        private static object _lock = new object();

        /// <summary>
        /// 单线程单例
        /// (线程不安全)
        /// </summary>
        /// <returns></returns>
        public static LazySingleton CreateIntance1()
        {
            //我们发现：在多线程中，实例创建了不止一次，原因是多个线程同时进入了
            if (_instance == null)
            {
                _instance = new LazySingleton();
            }
            return _instance;
        }

        /// <summary>
        /// 多线程的单例模式（线程安全+但是费时，费在锁上了）
        /// </summary>
        /// <returns></returns>
        public static LazySingleton CreateIntance2()
        {
            //给下面的语句整体加上锁，即使多线程，也需要一个一个的进入锁中进行判断，不存在同时进入创建实例内部的情况了。
           //缺点：同时带来一个问题，所有的线程必须等着前面一个锁完成后，方可进入，即使实例已经创建完了，也需要等前面的锁完成，这样多个线程耗时就耗在等锁上了
            lock (_lock)
            {
                if (_instance == null)
                {
                    _instance = new LazySingleton();
                }             
            }
            return _instance;
        }

        /// <summary>
        /// 多线程的单例模式（安全且不耗时）
        /// </summary>
        /// <returns></returns>
        public static LazySingleton CreateIntance3()
        {
            //外层再加一层if，在进锁前就可以判断了，如果前面已经有实例创建好了，那么以后的就不需要等锁了，但是也可能存在多线程同时进入第一个if，那么同时进入的也要等一下哦。
            if (_instance == null)
            {
                lock (_lock)
                {
                    if (_instance == null)
                    {
                        _instance = new LazySingleton();
                    }

                }
            }
            return _instance;
        }
    }

测试

 4. 适用场景分析 

(1). 在应用场景中，某类只要求生成一个对象的时候，如一个班中的班长、每个人的身份证号等。

(2). 当对象需要被共享的场合。由于单例模式只允许创建一个对象，共享该对象可以节省内存，并加快对象访问速度。如 Web 中的配置对象、数据库的连接池等。

(3). 当某类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池、网络连接池等。

!

• 作       者 : Yaopengfei(姚鹏飞)
• 博客地址 : http://www.cnblogs.com/yaopengfei/
• 声     明1 : 如有错误，欢迎讨论，请勿谩骂^_^。
• 声     明2 : 原创博客请在转载时保留原文链接或在文章开头加上本人博客地址，否则保留追究法律责任的权利。