一刷剑指offer笔记（2）——实现Singleton模式

题目：
设计一个类，我们只能生成该类的一个实例

Singleton模式是最简单的设计模式之一，它提供了创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。

这个类提供了一种访问其唯一对象的方式，可以直接访问，不需要实例化该类的对象，毕竟只有一个实例。

注意：

1、单例类只能有一个实例

2、单例类必须自己创建自己的唯一实例

3、单例类必须给所有其他对象提供这一实例

划重点！只能生成一个实例！

因此必须把构造函数设为私有函数以禁止他人创建实例。

先来看看不完美的解法：

给类设置两个静态属性Instance与instance，所谓的静态，就是独一无二的意思。

在静态属性Instance中，只有在instance为null的时候才创建一个实例。

构造函数为私有函数。

//sealed修饰类，表示该类不能被继承；修饰方法，表示该方法不能被重写（类似final）
public sealed class Singleton1
{
    private Singleton1()
    {
    }
    private static Singleton1 instance=null;
    public static Singleton1 InStance
    {
        //区分set与get函数
        //set:向类中的属性进行赋值
        //get:取出类中某属性的值
        get
        {
            if(instance==null)
                instance=new Singleton1();
            return instance;
        }
    }

貌似很完美，但是只是在单线程的时候工作正常。

试想如果有两个线程同时运行到判断instance是否为null的if语句，并且instance的确尚未创建，那么两个线程都会创建一个实例，此时类Singleton1就不再满足单例模式的要求。

针对这一点，进行改进——加上同步锁。

public sealed class Singleton2
{
    private Singleton2()
    {
    }
    //readonly与const的区别在于：readonly字段为运行时常量，const字段为编译时常量
    //这里的syncObj为引用类型，故必须在new关键字为它分配内存之后才能在后续代码中工作
    //而由于是动态分配内存，因此不可能在编译阶段就确定它的地址
    //readonly只是让syncObj无法再更改它的引用（地址不能修改），但它所引用对象的属性是可以改变的
    //readonly修饰的属性，只能在定义的时候或者构造函数中初始化
    private static readonly object syncObj=new object();
    private static Singleton2 instance=null;
    public static Singleton2 Instance
    {
        get
        {
            //lock(objectA){codeB}的三层含义
            //1、objectA被lock了吗？没有的话就由我lock，否则一直等待，直至objectA被释放
            //2、lock以后在执行codeB的期间其他线程不能调用codeB，也不能使用objectA
            //3、执行完codeB之后释放objectA,并且codeB可以被其他线程访问
            //假设有两个线程同时想创建一个实例，由于在一个时刻只有一个线程能得到同步锁
            //当第一个线程加上锁时，第二个线程只能等待
            //当第一个线程发现实例还未建立时，它创建出一个实例
            //第一个线程释放同步锁，第二个线程加上同步锁，运行代码
            //第二个线程发现实例已经被第一个线程创建出来，不再重复创建
            lock(syncObj)
            {
                if(instance==null)
                    instance=new Singleton2();
            }
            return instance;
        }
    }
}
        

这种方法依旧存在瑕疵，每次通过属性Instance得到Singleton2的实例时，都会试图加上一个同步锁，而加锁十分耗时，在没有必要的时候需要避免！

如何尽可能的避免少一点加锁次数呢？

加同步锁前后两次判断实例是否已经存在！！

我们只是在实例还未创建之前需要加锁操作，以保证只有一个线程创建出实例。而当实例已经创建之后，就不需要再加锁了。

进一步改进的代码：

public sealed class Singleton3
{
    private Singleton3()
    {
    }
    private static object syncObj=new Object();
    private static Singleton3 instance=null;
    public static Singleton3 Instance
    {
        get
        {
            if(instance==null)
            {
                lock(syncObj)
                {
                    if(instance==null)
                        instance=new Singleton3();
                }
            }
            return instance;
        }
     }
}

虽然问题被解决了，但是这样的代码实现比较麻烦。

在C#中，有一个函数能够确保只调用一次，即为静态构造函数。

静态构造函数在类的静态成员第一次访问或第一个实例创建之前被系统调用，且最多运行一次。

一个类中最多只能定义一个静态构造函数。

静态构造函数主要完成静态数据成员的初始化工作，若定义静态数据成员的时候进行初始化，同时在静态构造函数中进行了初始化，则以静态构造函数的初始化为准。

public sealed class Singleton4
{
    private Singleton4()
    {
    }
    //在初始化静态变量instance时创建一个实例
    //因为instance为静态变量，因此C#是在调用默认的静态构造函数初始化静态变量
    //由于运行时能够确保只调用一次静态构造函数，故能够保证只初始化一次instance
    private static Singleton4 instance=new Singleton4();
    public static Singleton4 Instance
    {
        get
        {
            return instance;
        }
    }
}

注意，C#中调用静态构造函数的时机并不是由程序员掌控，而是当.NET运行时发现第一次使用一个类型的时候自动调用该类型的静态构造函数。因此在Singleton4中，实例instance并不是第一次调用属性Singleton4.Instance的时候创建，而是在第一次用到Singleton4的时候就会被创建。

过早地创建实例，会降低内存的使用效率。

继续进行改进，利用内部私有类型。

public sealed class Singleton5
{
    Singleton5()
    {
    }
    //当第一次通过属性Singleton5.Instance得到Singleton5实例时，会自动调用Nested的静态构造函数创建实例instance
    public static Singleton5 Instance
    {
        get
        {
            return Nested.instance;
        }
    }
    class Nested
    {
        static Nested()
        {
        }
        internal static readonly Singleton5 instance=new Singleton5();
     }
}