【Basic Code】一道“单例”的笔试题

        题目：设计一个类，只能生成该类的一个实例。

                                        ---题记

        面试过程中，对于“设计模式”这块，由于“单例”非常具有代表性，同时代码量不大，实现起来比较简单，经常会被放到笔试部分让应聘者手写，

   写法一：私有构造方法

   最普通的写法，会利用静态的构造方法的写法来实现：

public sealed class Singleton1
{
	private Singleton1() //私有的构造函数
	{
	}
	
	private static Singleton1 instance = null; //声明静态的Singleton1变量
	
	public static Singleton1 Instance
	{
		get
		{
			if(instance == null)
				instance == new Singleton1();
			return instance;
		}
	}
}

    如上所述代码，或许是在学习设计模式时写出的通过私有构造函数以及创建静态的实例来创建一个新实例，这种写法满足了单线程条件下的“单例”需求，一旦两个线程同时调用Singleton1的Instance，恰好此时instance的状态均为null，就会创建出两个Singleton1实例，即在多线程条件下，这种写法失败。

   写法二：加同步锁

public sealed class Singleton2
{
	private Singleton2()
	{
	}
	
	private static readonly Object syncObj = new Object();
	
	private static Singleton2 instance = null; //声明instance变量
	public static Singleton2 Instance
	{
		get
		{
			//通过加入同步锁，多线程中只得到一个实例
			lock(syncObj)
			{
				if(instance == null)
					instance = new Singleton2();
			}
			return instance;
		}
	}
}

    这种写法，在要实例化单例的过程中（Instance属性），通过加入同步锁，使得其他的线程再来准备创建实例过程中，就要等待，直到持有实例的线程释放了资源，其他的线程才能去创建该实例，即保证了在多线程中也可以实现“单例”，完整地完成了任务。

    但是，这样的写法存在一些可优化的地方，比如：加同步锁的过程是一个非常耗时的过程，能不用时，尽量不使用，既然这样就要去想优化的方法。

    写法三：同步锁前后，判断实例是否已经存在

public sealed class Singleton3
{
	private Singleton3()
	{
	}
	
	private static readonly Object syncObj = new Object();
	
	private static Singleton3 instance = null;
	public static Singleton3 Instance
	{
		get
		{
			//加同步锁之前，先判断实例是否存在
			if(instance == null)
			{
				//通过加入同步锁，多线程中只得到一个实例
				lock(syncObj)
				{
					if(instance == null)
						instance = new Singleton3();
				}
				return instance;
			}
			
		}
	}
}

           如上代码所示，算是对写法二的优化（因为写法二已经满足了对于单线程、多线程的单例要求），对于写法二存在的同步锁时间开销，写法三通过在开启同步锁之前就判断实例是否存在，如果存在，则无需引入同步锁，这样子从概率的角度来分析，就减轻了一半的时间负担，对实例二的优化增强了，此时效率已经明显高于写法二了。

    但是，对于实例不存在，则仍需要继续开启同步锁，而且这种写法if(instance == null)的判断比较多，容易出错，仍然可以继续优化。

   写法四：静态构造函数

public sealed class Singleton4
{
	private Singleton4()
	{
	}
	
	private static Singleton4 instance = new Singleton4();
	
	public static Singleton4 Instance
	{
		get
		{
			return instance;
		}
	}
}

    如上代码所示，借助.NET框架的内置机制（java环境正在探索中），由这个静态构造函数，运行过程中调用一次静态构造函数，就能保证只初始化一次instance，相对于写法三，如果真的要创造该实例时，时间效率更快，没有了同步锁的等待时间。

    但是，过早地创造了实例，从而降低了内存的使用效率。

   写法五：按需创建实例

public sealed class Singleton5
{
	Singleton5()
	{
	}
	
	public static Singleton5 Instance
	{
		get
		{
			return Nested.instance; //通过调用属性
		}
	}
	
	//内部私有类型
	class Nested
	{
		static Nested()
		{
		}
		//静态构造函数创建实例
		internal static readonly Singleton5 instance = new Singleton5();
	}
}

      如上这种写法，在Singleton5的内部，定义一个私有类型Nested，第一次用到这个嵌套类型，调用静态构造函数创建Singleton5的实例Instance，类型Nested只在属性Sinleton5.Instance中被调用，第一次通过Singleton5.Instance自动调用Nested静态构造函数创建实例instance，真正做到了在需要时实时创建“单例”。

   

   虽然是C#代码实现的这个“单例”不断优化的写法，但在思路上以及性能上，却让人眼前一亮，积累到我的Basic Code系列中来。