文章目录
前言
一、单例模式(Singleton Pattern)
二、使用步骤
角色
示例
总结
优点
缺点
使用场景
前言
设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。
提示：以下是本篇文章正文内容，下面案例可供参考
一、单例模式(Singleton Pattern)
单例模式属于创建型模式，保证一个类仅有一个实例，并提供一个访问它的全局访问点。
一个类有且仅有一个实例，并且自行实例化向整个系统提供。
二、使用步骤
角色
1、单例类（Singleton）
保证唯一并提供全局访问点的单例类。
示例
命名空间SingletonPattern中包含7个单例类，本案例将介绍这7种常见的单例实现方法。
public sealed class Singleton { private static Singleton _instance = null; public static Singleton GetInstance() { if(_instance == null) { _instance = new Singleton(); Console.WriteLine("Singleton.GetInstance()!"); } return _instance; } }
最常见的单例类，但是无法保证线程安全。因为首次运行时，n个线程可同时到达if(_instance == null)，导致_instance可能会被多初始化n-1次（有1次是需要初始化的）。在_instance被初始化之后新启动的线程不会使该情况重现。
public sealed class SingletonSafe { private static SingletonSafe _instance = null; private static readonly object _lock = new object(); public static SingletonSafe GetInstance() { lock (_lock) { if (_instance == null) { _instance = new SingletonSafe(); Console.WriteLine("SingletonSafe.GetInstance()!"); } } return _instance; } }
使用私有静态object类型的锁（微软推荐），lock关键字会占有该锁，之后请求该锁的其它线程必需等待其释放才能进入。该方法可实现线程安全的单例模式，但是锁属于昂贵资源，“占有锁”和“释放锁”都比较耗时，并会在一定程度上阻止其它线程的执行，会显著影响程序的并发性，所以有了下面的优化。
public sealed class SingletonSafe2 { private static SingletonSafe2 _instance = null; private static readonly object _lock = new object(); public static SingletonSafe2 GetInstance() { if (_instance == null) { lock (_lock) { if (_instance == null) { _instance = new SingletonSafe2(); Console.WriteLine("SingletonSafe2.GetInstance()!"); } } } return _instance; } }
通过优先使用if (_instance == null)这种耗费资源较少的比较来决定是否进入锁，可大幅度提高性能。因为_instance不为null时，直接返回即可。
public sealed class SingletonLazy { private static readonly Lazy<SingletonLazy> _instance = new Lazy<SingletonLazy>(() => { Console.WriteLine("SingletonLazy.GetInstance()!"); return new SingletonLazy(); }); public static SingletonLazy GetInstance() { return _instance.Value; } }
带泛型的Lazy式单例实现，这是线程安全的，仅提供给大家参考。
public sealed class SingletonReadOnly { private static readonly SingletonReadOnly _instance = new SingletonReadOnly(); public SingletonReadOnly() { Console.WriteLine("SingletonReadOnly.GetInstance()!"); } public static SingletonReadOnly GetInstance() { return _instance; } }
静态只读式单例实现（由运行时保证唯一），这是线程安全的，仅提供给大家参考。
public abstract class SingletonGenericBase<T> where T : class, new() { private static T _instance = null; private static readonly object _lock = new object(); public static T GetInstance() { if (_instance == null) { lock (_lock) { if (_instance == null) { _instance = new T(); Console.WriteLine("SingletonGeneric.GetInstance()!"); } } } return _instance; } } public sealed class SingletonGeneric : SingletonGenericBase<Singleton> { public SingletonGeneric() { } }
复杂的泛型实现，这是线程安全的，仅提供给大家参考。
public abstract class SingletonGenericBase2<T> where T : class { private static readonly Lazy<T> _instance = new Lazy<T>(() => { var ctors = typeof(T).GetConstructors( BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public); if (ctors.Count() != 1) throw new InvalidOperationException( String.Format("Type {0} must have exactly one constructor.", typeof(T))); var ctor = ctors.SingleOrDefault( c => !c.GetParameters().Any() && c.IsPrivate); if (ctor == null) throw new InvalidOperationException( String.Format("The constructor for {0} must be private and take no parameters.", typeof(T))); Console.WriteLine("SingletonGeneric2.GetInstance()!"); return (T)ctor.Invoke(null); }); public static T GetInstance() { return _instance.Value; } } public sealed class SingletonGeneric2 : SingletonGenericBase2<SingletonGeneric2> { private SingletonGeneric2() { } }
复杂的泛型实现，这是线程安全的，仅提供给大家参考。
public class Program { public static void Main(string[] args) { var singleton = Singleton.GetInstance(); singleton = Singleton.GetInstance(); var singletonSafe = SingletonSafe.GetInstance(); singletonSafe = SingletonSafe.GetInstance(); var singletonSafe2 = SingletonSafe2.GetInstance(); singletonSafe2 = SingletonSafe2.GetInstance(); var singletonReadOnly = SingletonReadOnly.GetInstance(); singletonReadOnly = SingletonReadOnly.GetInstance(); var singletonLazy = SingletonLazy.GetInstance(); singletonLazy = SingletonLazy.GetInstance(); var singletonGeneric = SingletonGeneric.GetInstance(); singletonGeneric = SingletonGeneric.GetInstance(); var singletonGeneric2 = SingletonGeneric2.GetInstance(); singletonGeneric2 = SingletonGeneric2.GetInstance(); Console.ReadKey(); } }
以上是调用方的代码，每个GetInstance方法均调用2次以展示效果。以下是这个案例的输出结果：
Singleton.GetInstance()! SingletonSafe.GetInstance()! SingletonSafe2.GetInstance()! SingletonReadOnly.GetInstance()! SingletonLazy.GetInstance()! SingletonGeneric.GetInstance()! SingletonGeneric2.GetInstance()!
总结
优点
1、单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例；
2、因为类控制了实例化过程，所以类可以灵活更改实例化过程。
缺点
1、没有接口，不能继承，与单一职责原则冲突。
使用场景
1、需要频繁的进行创建和销毁的对象；
2、创建对象时耗时过多或耗费资源过多，但又经常用到的对象；
3、工具类对象；
4、频繁访问数据库或文件的对象。
