本文主要是记录《Head First 设计模式》知识，目的是检查自己学到的知识，同时方便我以后进行复习和浏览。

一、概述

1-1 定义

单例模式 Singleton Pattern：保证一个类只有一个实例，并提供一个访问它的全局访问点。又称为单件模式

单例模式有三个要点：

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

该模式是一种创建型模式。

1-2 模式结构

单例模式包含如下角色：

• Singleton:单例

图1 模式结构

二、举例：

2-1 经典的单例模式实现：

代码：

public class Singleton1
{
    //定义静态变量
    private static Singleton1 uniqueInstance;

    //私有构造函数，使外界不能创建该类实例
    private Singleton1() { }

    //定义共有方法提供一个访问点，该访问点为公有静态方法
    public static Singleton1 GetInstance()
    {
        if (uniqueInstance == null)
        {
            uniqueInstance = new Singleton1();
        }
        return uniqueInstance;
    }
}

经典的单例模式存在的问题：在单线程下完美，但是在多线程下就会有多个Singleton对象，如果两个线程同时调用GetInstance方法，则(uniqueInstance==null)都会判断真。下图分析产生多个对象的过程。

图2

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

解决经典单例模式问题：多线程情况下产生多个单例对象，当第一个线程创建该类的实例之后，后面的线程只需要直接判断uniqueInstance==null为假，直接返回第一个线程创建的对象。
代码：

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加锁之后再判断是否存在，如果第一个线程已经创建好单例对象，后面的线程没必要对线程辅助对象加锁之后再去判断uniqueInstance==null,可以直接判断uniqueInstance==null为假，然后返回第一个线程创建的单例对象。现在这个代码会增加额外的开销，损失了性能。

2-3 双重加锁单例模式

解决上方代码增加额外的开销，损失性能问题。在判断辅助对象locker是否加锁外添加对uniqueInstance == null判断，如果为假则证明已经有线程创建过对象，直接返回已经创建好的对象。如果为真则该线程加锁，然后再次判断uniqueInstance，并返回Singleton对象。
代码：

/// <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;
    }
}

三 总结

3-1 模式优缺点

优点

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

缺点

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

3-2 适合场景

特点：

• 该类不能被外界任一实例化
• 该类向外界提供一个可获得该类的实例的方法
• 系统只需要一个实例对象，如系统要求提供一个唯一的序列化生成器，或者需要考虑资源消耗太大而只允许创建一个对象。
• 在一个系统中要求一个类只要一个实例时才应当使用单例模式。反过来，如果一个类可以有几个实例共存，就需要对单例模式进行改进，使之成为多例模式。

3-3 模式应用

一个具有自动编号主键的表可以有多个用户同时使用，但数据库只能有一个地方分配下一个主键编号，否则会出现主键重复，因此该主键编号生成器必须具备唯一性，可以通过单例模式来实现。

项目中常用的地方：SQL、RabbitMQ、Redis等中间件，连接字符串类保证只有一个实例。

总结

• 单例模式确保程序中一个类最多只有一个实例。
• 单例模式也提供访问这个实例的全局点
• 在C#中实现单件模式需要私有构造器、一个静态方法和一个静态变量。
• 确保在性能和资源上的限制，然后小心地选择适当的方案实现单件，已解决多线程的问题（我们必须认定所有程序都是多线程的）。
• 小心，如果使用多个类加载器，可能会导致单件失效而产生多个实例。