C# -- 设计模式 -- Singleton Pattern 单例模式 (干货)

本文链接：https://blog.youkuaiyun.com/M1234uy/article/details/102892448

记录《Head First 设计模式》
参考 Graphic Design Patterns网站与深入设计模式
目的是检查学习情况，同时方便以后复习。

文章目录

一、简述
二、代码示例：
三、总结

一、简述

1-1 意图

单例模式 Singleton Pattern：保证一个类只有一个实例，并提供一个访问它的全局访问点。又称为单件模式或单态模式。该模式是一种创建型模式。

单例模式有三个要点：

某个类只有一个实例
它必须自行创建这个实例
它必须自行向整个系统提供这个实例

1-2 动机

对于系统的某些类来说，只有一个实例很重要。例如：线程池(threadpool)、缓存(cache)、对话框、注册表(registry)得对象、日志对象，充当打印机、显卡等设备的驱动程序的对象。

如何保证一个类只能有一个实例并且这个实例易于被访问呢？定义一个全局变量可以确保对象随时都可以被访问，但不能防止我们实例化多个对象。

更好的解决方案是：让类自身确保只有一个实例化。这个类没有被其他实例创建，并且提供一个访问该实例的方法。

1-3 模式结构

Singleton:单例

1-4 时序图

二、代码示例：

1-1 经典单例模式：

代码实现

/// <summary>
///  经典单例模式
/// </summary>
public class Singleton1
{
	/// <summary>
    /// 定义静态变量
    /// </summary>
    private static Singleton1 uniqueInstance;
	/// <summary>
    /// 私有构造函数，外界不允许创建该类实例
    /// </summary>
    private Singleton1() 
    { 
    }
    /// <summary>
    /// 定义共有方法提供一个访问点，该访问点为公有静态方法
    /// </summary>
    /// <returns></returns>
    public static Singleton1 GetInstance()
    {
        if (uniqueInstance == null)
        {
            uniqueInstance = new Singleton1();
        }
        return uniqueInstance;
    }
}

存在问题：

在单线程下完美，但是在多线程下可能会有多个Singleton对象。举例：如果两个线程同时调用 GetInstance 方法，则 uniqueInstance==null 都会判断真。下图为分析产生多个对象的过程。

1-2 多线程加锁单例模式

经典单例模式解决方案：

创建一个私有对象辅助的静态变量，当有线程调用 GetSingleton 方法时，锁定资源，保证多线程状态下只有一个实例。

代码实现：

/// <summary>
///  多线程加锁单例模式
/// </summary>
public class Singleton2
{
    /// <summary>
    /// 定义一个静态变量来保存类的实例
    /// </summary>
    private static  Singleton2 uniqueInstance;
    /// <summary>
    /// 定义一个标识确保线程同步
    /// </summary>
    private static readonly object locker = new object();
    /// <summary>
    /// 定义私有构造函数，使外界不能创建该类实例
    /// </summary>
    private  Singleton2() 
    { 
    }
    /// <summary>
    /// 定义一个全局访问点，同时也可以定义共有属性来提供全局访问点
    /// </summary>
    /// <returns></returns>
    public static Singleton2 GetSingleton()
    {
        //当第一个线程运行到这里，会对locker进行加锁
        //当第二个线程运行该方法时，首先检测locker对象为“加锁”状态，该线程就会挂起等待第一个线程解锁
        //lock语句运行完之后(即线程运行完之后)会对该对象进行“解锁”
        lock (locker)
        {
            if (uniqueInstance == null)
            {
                uniqueInstance = new Singleton2();
            }
        }
        return uniqueInstance;
    }
}

存在问题：

每个线程都会对线程辅助对象locker加锁之后再判断是否存在，如果第一个线程已经创建好单例对象，但之后的线程每调用一次GetInstance方法便加锁一次。现在这个代码会增加额外的开销，损失了性能。

1-3 双重加锁单例模式

解决多线程加锁性能损失问题：

在加锁之前判断一次静态实例变量 uniqueInstance 是否为空，若为空则对该线程加锁创建实例；若不为空则直接返回已经创建好的实例。

代码实现：

/// <summary>
/// 3、双重加锁
/// </summary>
public class Singleton3
{
    private static Singleton3 uniqueInstance;
    private static readonly object locker = new object();
    private Singleton3() { }
    public static Singleton3 GetInstance()
    {
        //当地一个线程运行到这里，会对locker对象进行“加锁”
        //当第二个线程运行该方法，首先检测到locker对象为“加锁”状态
        //lock语句运行完之后会对该对象“解锁”
        //双重锁定只需要一句判断就可以了
        if (uniqueInstance == null)
        {
            lock (locker)
            {
                if (uniqueInstance == null)
                {
                    uniqueInstance = new Singleton3();
                }
            }
        }
        return uniqueInstance;
    }
}

三、总结

1-1 模式分析

单例模式只包含一个角色，就是Singleton-单例类。

单例类的构造函数为私有。保证其他类无法通过 new 关键字实例化它。
提供一个自身的静态私有成员变量。存储单例类对象。
提供一个公有的静态工厂方法。该工厂方法检验实例的存在性并实例化自己，然后存储在静态变量中，以确保只有一个实例被创建。

1-2 模式优缺点

优点：

提供了唯一实例的受控访问。因为单例类封装了它的唯一实例，所以它严格控制客户怎样以及何时访问它，并为设计及开发团队提供了共享的概念。
由于在系统内存中只存在一个对象，因此节约系统资源，对于一些需要频繁创建和销毁的对象，单件模式可以提高系统的性能。
允许可变数目的实例。我们可以基于单例模式进行扩展，使用与单例控制相似的方法来获得指定个数的对象实例。

缺点：

由于单例模式中没有抽象层，因此单例类的扩展有很大的困难。
违反了“单一职责原则” ，该模式同时解决了两个问题。
滥用单例将带来一些负面的影响，如为了节省资源将数据库连接池对象设计为单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；现在很多面向对象的运行环境都提供了自动回收机制(继承IDisposable)，如果实例化的对象长时间不被利用，系统会认为它是垃圾自动销毁并回收资源，下次利用时又将重新实例化，导致共享的对象的状态丢失。