面向对象的设计模式系列之一：单件模式(Singleton)
大家好，由于工作繁忙导致很久没有更新博客了。结合我一直以来的工作经历和项目经验，谈一下个人关于设计模式的理解。其实这个话题是非常大的，也非常深入的，可能不能一时半会能全部展现整个设计模式的精髓。因此我的建议是：首先了解每种设计模式的应用场景和基本框架，模式只有在特定的环境下才能发挥强大的作用，其次我们延伸对设计模式的应用，因此模式不能死板硬套，否则就会变成为了模式而模式，那就非常不合适的。说到这，让我想起来一句话：在合适的时间，合适的地点遇到合适的人，也许才是你一生的挚爱。对设计模式而言：在特定的应用场景，怀着特定的意图并融合以及适当扩展设计模式，也许才是项目使用设计模式的王道。在讲解Sington模式之前，我顺便谈一下设计模式的分类：
从目的来看，分为创建型(Creational)模式: 负责对象的创建；结构型(Structural)模式:负责类与对象之间的组合；行为型(Behavioral)模式: 负责类与对象之间通信的职责分配。
从范围来看，分为类模式：处理类与子类的静态关系；对象模式：处理对象间的动态关系。
接下来我们开始进入Singleton模式的讲解了。
设计意图：保证一个类仅有一个实例，并提供一个访问该实例的全局访问点。
应用场景：在软件系统中，经常有一些特殊的类，必须保证在系统中有唯一的实例存在，才能保证整个逻辑正确性、用户无需修改任何代码即可使用。
实际案例: 大家通过MSN发送、接受实时消息时，所有请求必须通过集中的代理服务器的Http端口发送，虽然在那台代理服务器的80端口已经安排了很多工作，比如网页浏览以及B2B的Web Service调用，但却需要保证一个端口在同一时间内只能为一个进程打开。假设某个进程打开后没有及时关闭Http端口，导致其他任务无法及时的使用，这时这个进程则是代理服务器的唯一Singleton(单件)。同样，数据库的自增字段原理也类似: 假设A、B在不同的数据库会话中(无论是专用服务器还是共享服务器)，自增字段在A中出现1000,1001,1002,....,9999的同时，B也获得同样的结果，完全与A保持同步，那这时自增字段的序号生成部分也是一个Singleton(单件)。
那如何才能绕过常规的构造器，提供一种机制来保证类只有一个实例呢？我们说这应该是类的责任，而不是使用者的责任。必须满足以下三点：
（1）私有或保护构造函数以防止外部实例化。
（2）保存唯一实例的静态的私有变量。
（3）初始化并获得唯一实例的静态属性或方法。
首先，我们来看一下单线程下Singleton模式的实现。
public class Singleton
{
//1.保存唯一实例的静态的私有变量
private static Singleton instance;
//2.私有构造函数以防止外部实例化
private Singleton()
{
}
//3.初始化并获得唯一实例的静态属性或方法
public static Singleton Instance
{
get
{
if (instance == null)
{
instance = new Singleton();
}
return instance;
}
}
}
我们分析一下单线程的Singleton模式的几个要点：
（1）Singleton的实例构造函数也能以protected的方式允许子类派生。
（2）一般不支持ICloneable接口，因为这可能导致多个实例产生，与Singleton模式的初衷相违背。
（3）一般不支持序列化，因为这可能导致多个实例产生，与Singleton模式的初衷相违背。
（4）只考虑了对象的创建，而未考虑对象的销毁。但垃圾回收（GC）已经帮我们搭理了一切。
（5）不能应对多线程环境，使用单线程的Singleton模式在多线程下仍然可能产生多个对象。
为什么这样讲呢？假设在多线程下，两个不同的线程同时创建Singleton对象时，A对if(instance==null)的判断还未完成的同时，B也加入了判断，此时就可能导致A、B自产生一个Singleton对象，这显然使得这种实现具有局限性。接下来继续看多线程下Singleton模式的实现。
public class Singleton
{
//1.保存唯一实例的静态的私有变量
private static volatile Singleton instance = null;
private static object lockHelper = new object();
//2.私有构造函数以防止外部实例化
private Singleton()
{
}
//3.初始化并获得唯一实例的静态属性或方法
public static Singleton Instance
{
get
{
//double check操作
if (instance == null)
{
lock (lockHelper)
{
if (instance == null)
{
instance = new Singleton();
}
}
}
return instance;
}
}
}
我们发现多线程下的Singleton模式实现增加了一个辅助对象lockHelper和double check操作，其次增加了volatile对私有实例变量的修饰。double check操作保证了多个线程下由于lock为内层if(instance==null)构建了一个线程安全的小环境。而外层的if(instance==null)判断则可以防止多线程每次都会去锁定辅助对象而造成性能下降。而volatile则保证不受编译器优化，确保该字段在任何时候都能获得最新的值。即在被lock之后，如果还未完成new Singleton（）之前，instance都会保持null。 虽然double check实现了多线程下Singleton对象的创建，但依我们经验而言，为什么不把对象的构建过程放在静态构造函数里呢？其中一个原因就是编译器会"好心地"将静态成员instance构造次序重排，而.NET能使用指定的方法明确规定静态成员的构建次序，即静态构造函数必须在任何静态成员的初始化之前执行。我们接下来使用readonly改造double check的实现方式。
public class Singleton
{
public static readonly Singleton Instance = new Singleton();
private Singleton() {}
}
采用readonly方式实现是如此之简洁，而且可以保证多线程下Singleton的唯一实例，我将一一来解释原因。首先公有静态实例会在类第一次使用时被创建，并省去了Lazy构造过程和避免了编译器优化而带来的次序重排。其次私有构造函数防止了外部初始化。至于如何保证多线程下Singleton实例的唯一性，可以从IL代码中得以体现。使用idasm命令获得IL代码。
.class public auto ansi beforefieldinit DesignPattern.SingletonPattern.Static.Singleton
extends [mscorlib]System.Object
{
.field public static initonly class DesignPattern.SingletonPattern.Static.Singleton Instance
.method private hidebysig specialname rtspecialname static
void .cctor() cil managed
{
// Code size 11 (0xb)
.maxstack 8
IL_0000: newobj instance void DesignPattern.SingletonPattern.Static.Singleton::.ctor()
IL_0005: stsfld class DesignPattern.SingletonPattern.Static.Singleton DesignPattern.SingletonPattern.Static.Singleton::Instance
IL_000a: ret
} // end of method Singleton::.cctor
} // end of class DesignPattern.SingletonPattern.Static.Singleton
这里有一个beforefieldinit修饰符告诉CLR只有这里的静态成员(字段)在静态构造函数执行后才生效，即使有很多线程同时访问Instance，但都需等静态构造函数执行完成后才能使用。虽然Instance被定义为静态公有的，但却是只读的，一旦被创建将无法被任何线程改变，也就无需double check的检查了。我们也知道，对于每一个类静态构造函数只有一个且只能执行一次，接下来我们将readonly方式的内部原理代码给出来供大家参考，以方便理解我们刚才讲到的这些内容。
//与readonly直接实例化完全一致
public class Singleton
{
public static readonly Singleton Instance = null;
static Singleton()
{
Instance = new Singleton();
}
private Singleton() { }
}
谈到这里，对Singleton的基本结构也有了大致的了解，我们接下来以计数器为例来说明如何应用Singleton模式。
public class Counter
{
public static readonly Counter Instance = new Counter();
private Counter() { }
private int value;
public int Next
{
get { return ++value; }
}
public void Reset()
{
value = 0;
}
}
我们建立单元测试类，以计数器测试是否唯一。
[TestClass]
public class CounterTest
{
[TestMethod]
public void TestSingleton()
{
Counter.Instance.Reset();
var c1 = Counter.Instance;
var c2 = Counter.Instance;
Assert.AreEqual<Counter>(c1, c2);
Assert.AreEqual<int>(1, c1.Next);
Assert.AreEqual<int>(2, c2.Next);
Assert.AreEqual<int>(3, c1.Next);
}
}
我们看出c1，c2虽然创建了两次，但却是同一对象，c1在计数的同时c2也参与了计数，即系统中现在只存在唯一的实例。通过以上实例说明采用readonly方式实现Singleton模式虽如此简洁，但有一个缺点，无法实现带参的构造函数，如果要实现这个还必须回到以前的实现方式。
public class Singleton
{
//1.保存唯一实例的静态的私有变量
private static volatile Singleton instance = null;
private static object lockHelper = new object();
private string message = String.Empty;
//2.私有构造函数以防止外部实例化
private Singleton(string message)
{
this.message = message;
}
//3.初始化并获得唯一实例的静态属性或方法
public static Singleton Instance
{
get
{
//double check操作
if (instance == null)
{
lock (lockHelper)
{
if (instance == null)
{
var date = DateTime.Now.DayOfWeek == DayOfWeek.Saturday || DateTime.Now.DayOfWeek == DayOfWeek.Sunday;
instance = new Singleton(date ? "weekday" : "workday");
}
}
}
return instance;
}
}
public string Message
{
get { return this.message; }
}
}
但看看上面的代码直接硬编码过于僵化，将构造函数的参数直接具体化在程序中了，如果要改进这种方式，可以将属性改成方法或者配置文件实现。
public static Singleton GetInstance(string message)
{
//double check操作
if (instance == null)
{
lock (lockHelper)
{
if (instance == null)
{
//var message = ConfigurationManager.AppSettings["SingletonMessage"];
instance = new Singleton(message);
}
}
}
return instance;
}
到现在，我们明确Singleton模式定义了唯一的实例数量，但其根本目的在于保持操作的一致性，如更新计数器、更新整个应用程序的配置信息等。但随着业务的不断发展，需要Singleton产生指定的N个实例，可能有人会问：那这不是和Singleton产生唯一实例相违背了吗？和一般的new()有何区别？其实还是有不同点，首先来说这是对Singleton模式扩展，我们姑且称为Singleton-N模式。其次，这里的N是一个相对固定的数量，例如N=5，那产生1,2,3,4个实例时没有问题，5也可以，超过5个则已经超出系统容量了。我们来看以下如何实现这种模式。我们来分析以下如何利用以前的实现方式来解决Singleton-N模式，首先经典的Lazy构造方式不适合并发环境,PASS；采用readonly的静态构造函数无法构建对象数组实例，PASS；看来double check还有改造的空间，为了不打破这种方式，并且依据职责单一原则，我们建立辅助类WorkItemCollection，必须满足：
（1）本身应该是一个可以存在N个实例的集合类型。
（2）集合中的每个实例都能通过状态标识是否处于忙碌或闲暇，同时根据外部的反馈来修正自己的状态。
（3）可以告诉外界是否还有空位，以释放空间来创建对象。
从某种程度上来说，Singleton-N模式是ObjectPool模式的一个预备模式。它除了完成一般创建型模式的new()之外，还要控制检查实例的数量。那我们来看看如何实现吧。
辅助对象集合WorkItemCollection
/// <summary>
/// 实例的执行状态
/// </summary>
public enum Status
{
Busy,//实例被客户程序占用
Free//实例没有被客户程序占用
}
public interface IWorkItem
{
Status Status { get; set; }
void DeActivate();
}
/// <summary>
/// 定义Singleton实例集合
/// </summary>
/// <typeparam name="T"></typeparam>
public class WorkItemCollection<T> where T : class, IWorkItem
{
protected int max;//定义最多保存的实例数量
protected IList<T> items = new List<T>();
public WorkItemCollection(int max)
{
this.max = max;
}
/// <summary>
/// 外部获得T类型的入口
/// </summary>
/// <returns></returns>
public virtual T GetWorkItem()
{
if (items == null || items.Count == 0) return null;
//可能的话返回一个现成实例
foreach (T item in items)
{
if (item.Status == Status.Free)
{
item.Status = Status.Busy;
return item;
}
}
return null;//如果没有现成的实例则返回null
}
/// <summary>
/// 添加一个实例，默认状态为闲置
/// </summary>
/// <param name="item"></param>
public virtual void Add(T item)
{
if (item == null) throw new ArgumentNullException("item is null");
if (!IsAddNewInstance) throw new OverflowException();
item.Status = Status.Free;
items.Add(item);
}
/// <summary>
/// 是否还能添加新的实例
/// </summary>
public virtual bool IsAddNewInstance
{
get { return items.Count < max; }
}
}
Singleton-N模式实现
public class SingletonN : IWorkItem
{
private static readonly int MaxInstances = 2;//最多能产生的实例个数
private Status status = Status.Free;//初始状态
public Status Status
{
get { return this.status; }
set { this.status = value; }
}
public void DeActivate()
{
this.status = Status.Free;
}
//实现单件模式
private static WorkItemCollection<SingletonN> collection = new WorkItemCollection<SingletonN>(MaxInstances);
private static object lockHelper = new object();
private SingletonN() { }
//在Singleton主体框架不变下,引入集合实现多个实例的对象管理
public static SingletonN Instance
{
get
{
var instance = collection.GetWorkItem();
if (instance == null)
{
lock (lockHelper)
{
if (instance == null)
{
if (!collection.IsAddNewInstance) return null;
instance = new SingletonN();
collection.Add(instance);
}
}
}
instance.status = Status.Busy;//激活使用
return instance;
}
}
}
我们建立单元测试，以便验证当前Singleton-N模式实现的正确性。
[TestClass]
public class SingletonTest
{
[TestMethod]
public void TestSingletonN()
{
var c1 = SingletonN.Instance;
var c2 = SingletonN.Instance;
var c3 = SingletonN.Instance;
Assert.IsNull(c3);//c3因为没有空间而无法实例化
//证明c1,c2是两个不同的实例
Assert.AreNotEqual<int>(c1.GetHashCode(), c2.GetHashCode());
c1.DeActivate();//将c1的空间释放掉
c3 = SingletonN.Instance;//此时因为有了空间,c3可以获得空间实例化
Assert.IsNotNull(c3);
c2.DeActivate();
Assert.IsNotNull(c3);//此时仍然有空间,c3还是存在的
//c3虽然获得了新的空间,但该空间是属于之前c1或c2释放的
Assert.IsTrue(c3.GetHashCode() == c1.GetHashCode() || c3.GetHashCode() == c2.GetHashCode());
}
}
在注释中已经说明了一切，到这里，我想大家对Singleton模式的理解可能有很多新的认识，给人的感觉就是模式并不是一成不变的，而是千变万化的，但万变不离需求。我们只要掌握住了需求，并适当的扩展模式本身的实现，才能更好的应用设计模式。此外，Singleton模式也并不总是单独使用，它经常结合和其他模式一起使用，例如工厂模式中的工厂对象就常被设计成单件模式，此外外观模式(Facade)中的外观对象也经常被设计成单件模式，这些都是很好的范例，我将在以后的文章中谈到，希望大家可以从中捕捉到新的思想。在这里，我将源代码上传，大家可以打开运行，谢谢。
