单例模式

单例模式是最简单也最常用的的设计模式。

单例模式通常为了满足以下需求：设计一个类，只能生成该类的唯一实例。这个主要思想是构造器私有化，然后向外提供函数返回该类实例。网上不乏单例模式写法，却未好好总结优缺点，以至于新手非常迷茫。总的来说，单例模式有五种主要写法：

1. 饿汉法（未考虑新建对象内存损耗）

public class Singleton1 {
	private Singleton1(){ }
	
	private static Singleton1 s = new Singleton1();
	
	public static Singleton1 getInstance() {
		return this.s;
	}
}

因为其他类还未调用Singleton1.getInstance( )就已经预先产生了一个Singleton1对象实例；也就是未达到“延迟创建对象实例”的目的。但是，饿汉法也是一个不错的解法。因为多线程访问时，因为对象实例已经生成好，虽然线程未保证原子操作，但也不会产生一致性问题。

2. 单线程写法(未考虑多线程的原子操作)

考虑饿汉法预先创建实例的内存损耗，应该"延迟创建对象实例"。因而选择在getInstance()里实例化Singleton1。

public class Singleton2 {
	private Singleton2() {}
	
	private static Singleton2 s = null;;
	
	public static Singleton2 getInstance() {
		if(null == s) {
			s =  new Singleton2();
		}
		return s;
	}
}

然而多线程访问时，线程a、线程b可能同时调用方法getInstance()，重复创建对象实例。这样当然不安全，所以自然会想到对getInstance()加锁，保证多线程访问操作的原子性。

3. 多线程写法（未考虑重复申请/释放获得锁的时间）

考虑到多线程执行单例模式需要原子性，自然写出：

public class Singleton3 {
	private Singleton3() { }
	
	private static Singleton3 s = null;
	
	public static Singleton3 getInstance() {
		synchronized(this) {
			if(null == s) {
				s = new Singleton3();
			}
		}
		return s;
	}
}

 用了强制同步互斥锁synchronized（当然你也可以用没那么强的锁ReentranLock），可以非常肯定地保证getInstance( )的生成对象实例部分操作的原子性。然而，每次访问getInstance()都需要加锁。

在这个过程中，假如Singleton3对象实例已创建好，那么加锁是个重复操作，会带来不小时耗。如果在加锁前判断Singleton3对象实例是否为空就能改进这个问题。

4. 多线程改进写法（加锁前后两次判断是否存在该实例）

public class Singleton4 {
	private Singleton4() { }
	
	private static Singleton4 s = null;
	
	public static Singleton4 getInstance() {
		if(null == s) {
			synchronized(this) {
				s = new Singleton4();
			}
		}
		return s;
	}
}

在加锁前判断对象实例是否为null，若对象实例已存在可以避免每次访问getInstance( )都要加锁的无意义操作。

5. 内部类写法（饿汉法优化，黄金解法）

饿汉法我们姑且称为“空间换时间”，因为预先创建对象实例，多线程访问省去了很多加锁时耗。然而，我们可以把Singleton对象实例写在内部类。这样只有需要创建时，才会调用getInstance( )方法访问内部类中的Singleton实例。

但是，毫无疑问，势必要保证内部类只被加载一次，否则也会带来重复创建对象实例的问题。网上大多流行写成静态内部类：

public class Singleton5 {
	private Singleton5() { }
	
	public Singleton5 getInstance() {
		return Nest.s;
	}
	
	private static class Nest{
		private static Singleton5 s = new Singleton5();
	}
}

但我不太情愿只叫静态内部类写法。因为只有Java规定构造器不能静态，C#等其他语言是可以的。因为写成一个拥有静态构造器的内部类也能达到这个目的。因为静态构造器永远只执行一次：

public class Singleton6 {

	private Singleton6() { }
	
	public static Singleton6 getInstance() {
		return Nest.s;
	} 
	
	class Nest{
		static Nest() { }
		
		private static Singleton6 s = new Singleton6();
	}
}

 在面试中，面试官想要的是你能说出1，5两种解法。