单例模式

简介

单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的一个类只有一个实例。即一个类只有一个对象实例。

特点

1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例

实现

说到代码实现，主要是3点
1.私有静态变量
2.私有化构造函数
3.静态的对象获取方法
相信看到这的时候你心里就有个答案了，看看和下面的所谓懒汉模式的代码是不是一样。

懒汉模式，线程不安全

Copy

/// <summary>
/// 懒汉，线程不安全
/// </summary>
public class Singleton1
{
     private static Singleton1 _singleton = null;//私有静态变量

     private Singleton1() { }//私有化构造函数

     public static Singleton1 GetSingleton()//静态的对象获取方法
     {
          if (_singleton == null)//保证为空才创建
          {
               _singleton = new Singleton1();
          }
          return _singleton;
     }
}

如果这个答案和你想的一样，并一直也是这样用的，那只能说too young to simple，此方法其实有俩方面的问题，首先是线程不安全，如果同一时间，多个线程同时获取实例，则会出现获取到不同的实例，所谓的单例也就成了线程内单例，明显不对，解决办法往下看。

懒汉模式，线程安全

Copy

/// <summary>
/// 懒汉，线程安全
/// </summary>
public class Singleton2
{
     private static Singleton2 _singleton = null;
     private static object _lock = new object();

     private Singleton2() { }

     public static Singleton2 GetSingleton()
     {
          lock (_lock)//保证线程安全
          {
               if (_singleton == null)//保证为空才创建
               {
                    _singleton = new Singleton2();
               }
               return _singleton;
          }
     }
}

话不多说，看过代码的你多半你也会说一句，加锁大法好.到这我们基本上算是实现了，但是我们看看这个锁，虽然解决了多个实例对象问题，但是该方式运行效率却很低，下一个线程想要获取对象，就必须等待上一个线程释放锁之后，才可以继续运行，但实际上对象大部分情况是已经存在了的并不需要new，因此对上个方法做了个优化。

懒汉优化模式（双检锁/双重校验锁（double-checked locking））

Copy

/// <summary>
/// 懒汉优化
/// </summary>
public class Singleton3
{
     private static Singleton3 _singleton = null;
     private static object _lock = new object();

     private Singleton3() { }

     public static Singleton3 GetSingleton()
     {
          if (_singleton == null)//保证对象初始化之后，线程不需要等待锁
          {
               lock (_lock)//保证线程安全
               {
                    if (_singleton == null)//保证为空才创建
                    {
                         _singleton = new Singleton3();
                    }
               }
          }
          return _singleton;
     }
}

到这我们想要的单例模式基本算ok了，码得我自己都累，想想设计模式这么多年的沉淀，就没有简单点的写法么？答案当然是肯定有的，从实现方法的命名也可以看出，除了懒汉模式，还有对应的饿汉模式，相对来说写法比较简单。

饿汉模式

Copy

/// <summary>
/// 饿汉模式1
/// </summary>
public class Singleton4
{
     private static Singleton4 _singleton = null;

     private Singleton4()
     {

     }

     /// <summary>
     /// 静态构造函数，由CLR调用，在使用之前被调用，而且之调用一次
     /// </summary>
     static Singleton4()
     {
          _singleton = new Singleton4();
     }

     public static Singleton4 GetSingleton()
     {
          return _singleton;
     }
}

/// <summary>
/// 饿汉模式2
/// </summary>
public class Singleton5
{
     /// <summary>
     /// 静态变量：会在类型第一次使用的时候初始化，而且只初始化一次
     /// </summary>
     private static Singleton5 _singleton = new Singleton5();

     private Singleton5()
     {

     }

     public static Singleton5 GetSingleton()
     {
          return _singleton;
     }  
}

以上俩种方式，我个人认为是等价的，一个应用了静态变量，一个用的静态构造函数。虽然写法相对简单，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。嗨，有问题总得解决，看看下面。

登记模式（静态内部类）

Copy

public class Singleton6
{
     private static class SingletonHolder
     {
          internal static Singleton6 _singleton = new Singleton6();
     }

     private Singleton6() { }

     public static Singleton6 GetSingleton()
     {
          return SingletonHolder._singleton;
     }
}

这种方式同样利用了静态变量的机制来保证初始化 instance 时只有一个线程，同时又解决了lazy loading。因为 SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance。想象一下，如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在 Singleton 类加载时就实例化，这个时候，这种方式相对来说比较实用。

综述

一般情况下，懒汉优化模式更多的是让我们从头出发，理解单例模式的运行过程和实现思路，建议使用饿汉方式（Singleton4/Singleton5）。只有在要明确实现 lazy loading 效果时，才会使用登记模式。