设计模式-创建型-单例模式

前言：

　　单例模式，顾名思义，只存在一个实例。官方定义：对于类的单例模式设计，就是采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）。

　　单例模式在写法上有很多种，有饿汉式（类加载的时候实例化），懒汉式（类在使用的时候实例化），保证线程安全的写法等。具体如下：(删除线表示不推荐使用)

　　　　① 饿汉式（静态常量） 

　　　　② 饿汉式（静态代码块）

　　　　③ 懒汉式（线程不安全）

　　　　④ 懒汉式（线程安全，同步方法）

　　　　⑤ 懒汉式（线程安全，同步方法）

　　　　⑥ 双重检查double check

　　　　⑦ 静态内部类

　　　　⑧ 枚举

　　在IOC模式中，通常使用生命周期来实现单例，如services.AddSingleton<MyClass>();

正文：

★饿汉式（静态常量）

internal class Program
{
    private static void Main(string[] args)
    {
        // 测试
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();

        Console.WriteLine(instance1 == instance2);
        Console.WriteLine($"instance1.GetHashCode={instance1.GetHashCode()}");
        Console.WriteLine($"instance2.GetHashCode={instance2.GetHashCode()}");
    }
}

internal class Singleton
{
    /// <summary>
    /// 1、私有化构造函数，外部不能new
    /// </summary>
    private Singleton()
    {
    }

    // 2、本类的内部创建对象实例
    private readonly static Singleton instance = new Singleton();

    // 3、提供一个公有的静态方法，返回对象实例
    public static Singleton getInstance()
    {
        return instance;
    }
}

　　优缺点说明：

　　　　1、优点：写法简单，就是在类状态的时候就完成了实例化，避免线程同步问题。

　　　　2、缺点：在类装载的时候完成实例化，没有达到lazy loading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。

　　　　3、这种方式基于class loader机制避免了多线程的同步问题，不过，instance在类装载时就实例化，在单例模式中大多数都是调用getInstance方法，但是导致类装载的原因有很多，因此不能确定有其他的方式导致装载，这时候初始化instance就没有达到lazy loading的效果。

　　结论：这种单例模式可用，可能造成内存浪费。

★饿汉式（静态代码块）

internal class Program
{
    private static void Main(string[] args)
    {
        // 测试
        Singleton instance1 = Singleton.GetInstance;
        Singleton instance2 = Singleton.GetInstance;

        Console.WriteLine(instance1 == instance2);
        Console.WriteLine($"instance1.GetHashCode={instance1.GetHashCode()}");
        Console.WriteLine($"instance2.GetHashCode={instance2.GetHashCode()}");
    }
}

internal class Singleton
{
    /// <summary>
    /// 1、私有化构造函数，外部不能new
    /// </summary>
    private Singleton()
    {
    }

    public static Singleton GetInstance { get; private set; } = new Singleton();
}

★懒汉式（线程不安全）

internal class Program
{
    private static void Main(string[] args)
    {
        // 测试
        Singleton1 instance1 = Singleton1.getInstance();
        Singleton1 instance2 = Singleton1.getInstance();

        Console.WriteLine(instance1 == instance2);
        Console.WriteLine($"instance1.GetHashCode={instance1.GetHashCode()}");
        Console.WriteLine($"instance2.GetHashCode={instance2.GetHashCode()}");
    }
}

internal class Singleton1
{
    // 私有的静态变量
    private static Singleton1 instance;

    /// <summary>
    /// 1、私有化构造函数，外部不能new
    /// </summary>
    private Singleton1()
    {
    }

    /// <summary>
    /// 提供一个静态的公有方法，当使用到该方法时，才去创建instance，即懒汉式
    /// </summary>
    /// <returns></returns>
    public static Singleton1 getInstance()
    {
        if (instance == null)
        {
            instance = new Singleton1();
        }
        return instance;
    }
}

　　优缺点说明：

　　　　1、起到了lazy loading效果，但是只能在单线程下使用。

　　　　2、若在多线程下，一个线程进入if(singleton==null)判断语句块，还未来得及往下执行，另一个线程也通过了该判断，就会产生多个实例。所以在多线程环境下不可使用这种方式。

　　结论：在实际开发中，不要使用这种方式。

★懒汉式（线程安全，同步方法） 

internal class Program
{
    private static void Main(string[] args)
    {
        // 测试
        Singleton3 instance1 = Singleton3.getInstance();
        Singleton3 instance2 = Singleton3.getInstance();

        Console.WriteLine(instance1 == instance2);
        Console.WriteLine($"instance1.GetHashCode={instance1.GetHashCode()}");
        Console.WriteLine($"instance2.GetHashCode={instance2.GetHashCode()}");
    }
}

internal class Singleton3
{
    // 定义一个静态变量来保存类的实例
    private static Singleton3 instance;

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

    /// <summary>
    /// 私有化构造函数，外部不能new
    /// </summary>
    private Singleton3()
    {
    }

    /// <summary>
    /// 提供一个静态的公有方法，当使用到该方法时，才去创建instance，即懒汉式
    /// </summary>
    /// <returns></returns>
    public static Singleton3 getInstance()
    {
        // 当第一个线程运行到这里时，此时会对locker对象 "加锁"，
        // 当第二个线程运行该方法时，首先检测到locker对象为"加锁"状态，该线程就会挂起等待第一个线程解锁
        // lock语句运行完之后（即线程运行完之后）会对该对象"解锁"
        lock (locker)
        {
            if (instance == null)
            {
                instance = new Singleton3();
            }
        }
        return instance;
    }
}

　　优缺点说明：

　　　　1、解决了线程不安全的问题。

　　　　2、效率太低，每个线程都想获取类实例的时候，执行getInstance()时都需要进行同步，而该方法只需要执行一次实例化代码就够了，后面想获取该类的实例直接return就可以了。

　　结论：在实际开发中，不推荐使用这种方式。　　　　

★懒汉式（线程安全，同步代码块） 

internal class Program
{
    private static void Main(string[] args)
    {
        // 测试
        Singleton4 instance1 = Singleton4.getInstance();
        Singleton4 instance2 = Singleton4.getInstance();

        Console.WriteLine(instance1 == instance2);
        Console.WriteLine($"instance1.GetHashCode={instance1.GetHashCode()}");
        Console.WriteLine($"instance2.GetHashCode={instance2.GetHashCode()}");
    }
}

internal class Singleton4
{
    // 定义一个静态变量来保存类的实例
    private static Singleton4 instance;

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

    /// <summary>
    /// 私有化构造函数，外部不能new
    /// </summary>
    private Singleton4()
    {
    }

    /// <summary>
    /// 提供一个静态的公有方法，当使用到该方法时，才去创建instance，即懒汉式
    /// </summary>
    /// <returns></returns>
    public static Singleton4 getInstance()
    {
        if (instance == null)
        {
            lock (locker)
            {
                instance = new Singleton4();
            }
        }
        return instance;
    }
}

 

　　优缺点说明：

　　　　1、这种方式本意上时对上述方式的改进，改为同步产生实例化的代码块。

　　　　2、但是这种方式没有解决线程安全问题。　　

　　结论：强烈不推荐。

★双重检查 

internal class Program
{
    private static void Main(string[] args)
    {
        // 测试
        Singleton5 instance1 = Singleton5.getInstance();
        Singleton5 instance2 = Singleton5.getInstance();

        Console.WriteLine(instance1 == instance2);
        Console.WriteLine($"instance1.GetHashCode={instance1.GetHashCode()}");
        Console.WriteLine($"instance2.GetHashCode={instance2.GetHashCode()}");
    }
}

internal class Singleton5
{
    // 定义一个静态变量来保存类的实例
    private static Singleton5 instance;

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

    /// <summary>
    /// 私有化构造函数，外部不能new
    /// </summary>
    private Singleton5()
    {
    }

    /// <summary>
    /// 提供一个静态的公有方法，当使用到该方法时，才去创建instance，即懒汉式
    /// </summary>
    /// <returns></returns>
    public static Singleton5 getInstance()
    {
        // 当第一个线程运行到这里时，此时会对locker对象 "加锁"，
        // 当第二个线程运行该方法时，首先检测到locker对象为"加锁"状态，该线程就会挂起等待第一个线程解锁
        // lock语句运行完之后（即线程运行完之后）会对该对象"解锁"
        // 双重锁定只需要一句判断就可以了
        if (instance == null)
        {
            lock (locker)
            {
                if (instance == null)
                {
                    instance = new Singleton5();
                }
            }
        }
        return instance;
    }
}

　　结论：推荐使用。 

★静态内部类 

internal class Program
{
    private static void Main(string[] args)
    {
        // 测试
        Singleton2 instance1 = Singleton2.getInstance();
        Singleton2 instance2 = Singleton2.getInstance();

        Console.WriteLine(instance1 == instance2);
        Console.WriteLine($"instance1.GetHashCode={instance1.GetHashCode()}");
        Console.WriteLine($"instance2.GetHashCode={instance2.GetHashCode()}");
    }
}

internal class Singleton2
{
    /// <summary>
    /// 1、私有化构造函数，外部不能new
    /// </summary>
    private Singleton2()
    {
    }

    private static class SingletonInstance
    {
        public readonly static Singleton2 INSTANCE = new Singleton2();
    }

    /// <summary>
    /// 提供一个静态的公有方法，当使用到该方法时，才去创建instance，即懒汉式
    /// </summary>
    /// <returns></returns>
    public static Singleton2 getInstance()
    {
        return SingletonInstance.INSTANCE;
    }
}

　　优缺点说明：

　　　　1、这种方式采用了类装载的机制来保证初始化实例时只有一个线程。

　　　　2、静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，通过getInstance方法才会装载SingletonInstance类，从而完成Singleton实例化。

　　　　3、类的静态属性只会在类第一次装载的时候初始化。

　　　　4、避免了线程不安全，利用静态内部类特点实现延迟加载，效率高。

　　结论：推荐使用。 

★枚举

　　 

　　在java中提供该方式。 

C#中实现了单例模式的类：

// 该类不是一个公开类
// 但是该类的实现应用了单例模式
internal sealed class SR
{
    private static SR loader;
    internal SR()
    {
    }
    // 主要是因为该类不是公有，所以这个全部访问点也定义为私有的了
     // 但是思想还是用到了单例模式的思想的
     private static SR GetLoader()
    {
         if (loader == null)
         {
             SR sr = new SR();
             Interlocked.CompareExchange<SR>(ref loader, sr, null);
         }
        return loader;
    }

    // 这个公有方法中调用了GetLoader方法的
    public static object GetObject(string name)
    {
         SR loader = GetLoader();
         if (loader == null)
         {
               return null;
         }
         return loader.resources.GetObject(name, Culture);
    }
}

参考：https://www.cnblogs.com/zhili/p/SingletonPatterm.html