Design Pattern学习(C#) ---- Singleton
Singleton模式：
Singleton（单件或单态）模式是设计模式中比较简单而常用的模式。
有时候在整个应用程序中，会要求某个类有且只有一个实例，这个时候可以采用Singleton模式进行设计。用Singleton模式设计的类不仅能保证在应用中只有一个实例，而且提供了一种非全局变量的方法进行全局访问，称为全局访问点，这样对于没有全局变量概念的纯面向对象语言来说是非常方便的，比如C#。
首先看看两种标准的实现方法：
方法一：
using System;namespace DesignPattern.Singleton
{
public class Singleton
{
static Singleton instance= new Singleton();
private Singleton() {}
static public Singleton Instance()
{
return instance;
}
}
}
方法二：
using System;
namespace DesignPattern.Singleton
{
public class Singleton
{
static Singleton instance;
private Singleton() {}
public static Singleton Instance()
{
if (null == instance)
{
instance = new Singleton();
}
return instance;
}
}
}
Singleton模式的技巧和要点：
Singleton模式的实现有两个技巧：
一是使用静态成员变量保存“全局”的实例，确保了唯一性，使用静态的成员方法Instance() 代替new关键字来获取该类的实例，达到全局可见的效果。
二是将构造方法设置成为private，如果使用new关键字创建类的实例，则编译时会报错。
然后，我们来看看单线程Singleton模式的几个要点：
1. Singleton模式中的实例构造器可以设置为protected以允许子类派生。
2. Singleton模式一般不要支持ICloneable接扣，因为这可能会导致对个对象实例，与其初衷违背。
3. Singleton模式一般不要支持序列化，因为这也有可能导致对个对象实例。
4. Singleton模式只考虑了对象创建的管理，没有考虑对象销毁的管理。就支持垃圾回收的平台和对象的开销来讲，我们没必要对其进行特殊的管理。
5. 不能应对多线程环境，在多线程环境下，使用Singleton模式仍然有可能得到Singleton类的对个对象实例。
上面方法二的初始化方式称为lazy initialization，是在第一次需要实例的时候才创建类的实例，与方法一中类的实例不管用不用一直都有相比，方法二更加节省系统资源。但是方法二在多线程应用中有时会出现多个实例化的现象。假设这里有2个线程：主线程和线程1，在创建类的实例的时候可能会遇到一些原因阻塞一段时间（比如网络速度或者需要等待某些正在使用的资源的释放），此时的运行情况如下：
主线程首先去调用Instance()试图获得类的实例，Instance()成员方法判断该类没有创建唯一实例，于是开始创建实例。由于一些因素，主线程不能马上创建成功，而需要等待一些时间。此时线程1也去调用Instance()试图获得该类的实例，因为此时实例还未被主线程成功创建，因此线程1又开始创建新实例。结果是两个线程分别创建了两次实例，对于计数器类来说，就会导致计数的值被重置，与Singleton的初衷违背。解决这个问题的办法是同步。
Singleton模式示例：
我们以简单的计数作为示例，来看其具体实现：
使用方法一：
using System;namespace DesignPattern.Singleton
{
public class Counter
{
static Counter instance = new Counter(); //存储唯一的实例。
private int totCount = 0; //存储计数值。
private Counter()
{
//这里假设因为某种因素而延迟了100毫秒。
//在非lazy initialization 的情况下, 不会影响到计数。
System.Threading.Thread.Sleep(100);
}
public static Counter Instance()
{
return instance;
}
public void Inc() { totCount++; } //计数加1。
public int GetCounter() { return totCount; } //获得当前计数值。
}
}
使用方法二：
using System;
using System.Runtime.CompilerServices;namespace csPattern.Singleton
{
public class Counter_lazy
{
static Counter_lazy instance;
private int totCount = 0;
private Counter_lazy()
{
System.Threading.Thread.Sleep(100); //假设多线程的时候因某种原因阻塞100毫秒
}[MethodImpl(MethodImplOptions.Synchronized)] //方法的同步属性
public static Counter_lazy Instance()
{
if (null == instance)
{
instance = new Counter_lazy();
}
return instance;
}public void Inc() { totCount++; }
public int GetCounter() { return totCount; }
}
}
以下是调用Counter类的客户程序，在这里我们定义了四个线程同时使用计数器，每个线程使用5次，最后得到的正确结果应该是20：
using System;
using System.Threading;namespace DesignPattern.Singleton
{
public class MutileClient
{
public MutileClient() { }
public void DoWork()
{
Counter myCounter = Counter.Instance(); //方法一
//Counter_lazy myCounter = Counter_lazy.Instance(); //方法二
for (int i = 1; i <= 5; i++)
{
myCounter.Inc();
Console.WriteLine("线程{0}: 当前counter为: {1}",
Thread.CurrentThread.Name.ToString(), myCounter.GetCounter().ToString());
}
}public void ClientMain()
{
Thread thread0 = Thread.CurrentThread;
thread0.Name = "Thread 0";
Thread thread1 = new Thread(new ThreadStart(this.DoWork));
thread1.Name = "Thread 1";
Thread thread2 = new Thread(new ThreadStart(this.DoWork));
thread2.Name = "Thread 2";
Thread thread3 = new Thread(new ThreadStart(this.DoWork));
thread3.Name = "Thread 3";
thread1.Start();
thread2.Start();
thread3.Start();
DoWork(); //线程0
}
}
}
下面则是程序入口：
using System;namespace DesignPattern.Singleton
{
class Program
{
static void Main(string[] args)
{
MutileClient myClient = new MutileClient();
myClient.ClientMain();
System.Console.ReadLine();
}
}
}
由于系统线程调度的不同，每次的执行结果也不同，但是最终结果一定是20。
方法一中，由于实例一开始就被创建，所以Instance()方法无需再去判断是否已经存在唯一的实例，而返回该实例，所以不会出现计数器类多次实例化的问题。
方法二中，在Instance()方法上方的[MethodImpl(MethodImplOptions.Synchronized)] 语句，它就是同步的要点，它指定了Instance()方法同时只能被一个线程使用，这样就避免了线程0调用instance()创建完成实例前线程1就来调用Instance()试图获得该实例。似乎还可以使用Mutex类进行同步，我不清楚怎么用，整明白后再贴上。
另外，C#也可以使用lock关键字进行线程的加锁，代码如下：
public class Counter_lazy_lock
{
static Counter_lazy_lock instance;
static object myObject = new object();
private int totCount = 0;private Counter_lazy_lock()
{
Thread.Sleep(100);
}public static Counter_lazy_lock Instance()
{
lock (myObject)
{
if (null == instance)
{
instance = new Counter_lazy_lock();
}
return instance;
}
}public void Inc() { totCount++; }
public int GetCounter() { return totCount; }
}
最后让我们看看，利用.NET Framework平台优势实现的Singleton模式的代码：
sealed class SingletonClass
{
private Singleton() { }
public static readonly Singleton Instance=new Singleton();
}
可以看到，代码减少了许多，实际上它也同时也解决了线程问题带来的性能上损失。
SingletonClass被声明为sealed，以保证它不会被继承，其次没有了Instance方法，将原来instance成员变量变成public readonly，并在声明时被初始化。通过这些改变，我们确实得到了Singleton的模式，原因是在JIT的处理过程中，如果类中的static属性被任何方法使用时，.NET Framework将对这个属性进行初始化，于是在初始化Instance属性的同时Singleton类实例得以创建和装载。而私有的构造函数和readonly保证了Singleton不会被再次实例化，这正是Singleton模式的意图。
