从头学习设计模式（一）——单例模式

【原】从头学习设计模式（一）——单例模式

一、引入

　　单例模式作为23种设计模式中的最基础的一种模式，在平时开发中应用也非常普遍。到底哪些类应该设计成单例的呢，我们来举个最通俗的例子。在一个父容器中单击某个菜单项打开一个子窗口，如果不使用单例又没有作菜单项的可用控制的话，每次单击菜单项都会打开一个新窗口。这不仅会浪费内存资源，在程序逻辑上也是不可以接受的。

二、最简单的单例

　　下面来看一个最简单的单例模式的构造形式

public class Program
{
private static void Main(string[] args)
{

GetInstance();
Console.ReadLine();
}

private void GetInstance()
{
Singleton objectSingleton = Singleton.getInstance();
}
}

public class Singleton
{
private static Singleton instance = null;
private Singleton()
{
}

public static Singleton getInstance()
{
if (instance == null)
{
instance = new Singleton();
Console.WriteLine("Create a singleton instance!");
}
return instance;
}
}

　　这里通过几个关键的地方以保证返回唯一的实例：

私有的构造器，防止客户端用new关键字去创建实例对象
静态的instance对象，保证全局唯一性
对外的公共的静态实例方法，从类级别直接可调用此方法
通过判断null值，决定是创建新实例还是直接返回。

三、并发下的单例

　　不过，以上标准的单例构造模式在多并发的情况下就有可能失效，请参考下面的这种情况。

private static void Main(string[] args)
{
//开启10个线程来模拟多并发的情况
for (int i = 0; i < 10; i++)
{
Thread thread = new Thread(new ThreadStart(GetInstance));
thread.Start();
}
Console.ReadLine();
}

private static void GetInstance()
{
Singleton objectSingleton = Singleton.getInstance();
}
}

public class Singleton
{
private static Singleton instance = null;
private Singleton()
{
}

public static Singleton getInstance()
{
//让线程睡一会，来模拟有多个进程都已经在调用getInstance方法
Thread.Sleep(10);
if (instance == null)
{
instance = new Singleton();
Console.WriteLine("Create a singleton instance!");
}
return instance;
}
}

　　以上的程序中开启了10个线程，来模拟多个用户同时访问getInstance方法。在getInstance方法里，开始先让线程睡一会，以模拟多个线程都已经进入了该方法。从运行的结果看上，基本上不能保证实例化唯一的实例了。



　　产生这种问题的原因就是，当一个线程进入getInstance 方法，通过了 instance==null 的条件，还没有来的及执行 instance = new Singleton() 时，另一个线程也通过了条件判断，这时就会 new Singleton() 多次了。
　　解决的办法就是加锁,只让一个线程进来，参考以下代码：

public class Program
{
private static void Main(string[] args)
{
//开启100个线程来模拟多并发的情况
for (int i = 0; i < 100; i++)
{
Thread thread = new Thread(new ThreadStart(GetInstance));
thread.Start();
}
Console.ReadLine();
}

private static void GetInstance()
{
Singleton objectSingleton = Singleton.getInstance();
}
}

public class Singleton
{
private static Singleton instance = null;
private static readonly object objForLock=new object();
private Singleton()
{
}

public static Singleton getInstance()
{
//让线程睡一会，来模拟有多个进程都已经在调用getInstance方法
Thread.Sleep(10);
//加一道锁只让一个线程进来
lock (objForLock)
{
if (instance == null)
{
instance = new Singleton();
Console.WriteLine("Create a singleton instance!");
}
}
return instance;
}
}

　　这样差不多可以达到我们的要求，只有一个实例对象存在可以保证了，但是这样会带来一点性能问题。如果每个线程进入getInstance方法后，都要lock一下以进行线程同步的话，每个线程到这里都要等待解锁后才能进入，但是如果 instance已经不是null了，那就应该直接返回而不是等待解锁，所以这里需要引入“双重锁”的单例构造方法，代码如下：

private static void Main(string[] args)
{
//开启100个线程来模拟多并发的情况
for (int i = 0; i < 100; i++)
{
Thread thread = new Thread(new ThreadStart(GetInstance));
thread.Start();
}
Console.ReadLine();
}

private static void GetInstance()
{
Singleton objectSingleton = Singleton.getInstance();
}
}

public class Singleton
{
private static Singleton instance = null;
private static readonly object objForLock=new object();
private Singleton()
{
}

public static Singleton getInstance()
{
//让线程睡一会，来模拟有多个进程都已经在调用getInstance方法
Thread.Sleep(10);
//先判断是不是已经实例化过了，避免进入锁等待状态
if(instance ==null)
{
//加一道锁只让一个线程进来
lock (objForLock)
{
if (instance == null)
{
instance = new Singleton();
Console.WriteLine("Create a singleton instance!");
}
}
}

return instance;
}
}

四、“懒汉式”单例与“饿汉式”单例的比较

　　所谓的“懒汉式”与“饿汉式”，就是实例对象的初始化时间不同：
　　1. 在需要实例化的时候才进行实例化，就是懒汉式。我们上面的这些例子都是懒汉式的。懒汉式有好处当然是节省资源啦，需要的时候才去构造，平时不用占用内存。不过，这会带来上面提到的在多并发下需要加锁限制访问的问题。
　　2.类加载时就直接进行实例化，就是饿汉式。例如下面的代码：

private static Singleton instance = new Singleton();

private Singleton() {

}

public static Singleton getInstance() {
return instance;
}

　　饿汉式单例是当类第一次被加载时就会将instance进行实例化，这样作的好处是不会带来多并发下的线程安全问题了，也不用考虑锁了。但反过来带来的就是性能问题了，因为不管你需不需要将这个实例对象创建出来，它都已经被创建出来常驻内存了。所以如果是一个工厂模式、缓存了很多实例、那么就得考虑效率问题，因为这个类一加载则把所有实例不管用不用一块创建。

　　这里只是对两种构造模式作了一个简单的对比，实际项目中要应用哪种模式还是要看具体需求而定。