剑指offer(1) - 实现Singleton模式

单例模式面试中经常会问到的一个知识点，这也是一个很简单的设计模式，几行代码就能实现，但是这几行代码中也蕴藏着不少知识点，下面我们逐一进行分析：

※不好的解法一：只适用于单线程环境

public class Singleton1 {
	private static Singleton1 instance = null;

	private Singleton1() {
	}

	public static Singleton1 getInstance() {
		if (instance == null) {
			instance = new Singleton1();
		}
		return instance;
	}
}

上面的写法只能在单线程中使用，多线程环境下有可能会创建多个实例，就不能满足我们的需求了。

例如当两个线程都运行到判断instance是否为null的if判断，此时就会执行两次new操作。

※ 不好的解法二：虽然在多线程环境中能工作但效率不高

public class Singleton2 {
	private static Object lock = new Object();
	private static Singleton2 instance = null;

	private Singleton2() {
	}
	
	public static Singleton2 getInstance() {
		synchronized (lock) {
			if (instance == null) {
				instance = new Singleton2();
			}
		}
		return instance;
	}
}

解决多线程的问题我们会想到的解决方案是加同步锁，如上代码；需要注意的是多个线程必须使用同一把锁，否则这个锁就形同虚设了。然而上面的代码却存在严重的性能问题，因为每次获取实例对象的时候都会试图加上同步锁，而我们知道加锁是一个非常耗时的操作，我们需要思考一个问题：如果实例对象已经存在了，我们干吗还要加同步锁，为什么不直接返回实例对象给调用者？

※ 可行的解法三：加锁并前后判空

public class Singleton3 {
	private static Object lock = new Object();
	private static Singleton3 instance = null;

	private Singleton3() {
	}
	
	public static Singleton3 getInstance() {
		if(instance == null){
			synchronized (lock) {
				if (instance == null) {
					instance = new Singleton3();
				}
			}
		}
		return instance;
	}
}

对解法二我们可以做进一步的改进：即只有当instance为null即没有创建时，需要加锁操作。当instance已经创建出来之后，则无需加锁。这样效率会高很多。

※ 可行的解法四：饿汉式单例

public class Singleton4 {
	private static Singleton4 instance = new Singleton4();;

	private Singleton4() {
	}

	public static Singleton4 getInstance() {
		return instance;
	}
}

所谓的饿汉就是一上来我就给你new一个实例，当调用获取实例的方法的时候我就可以马上返回一个实例给你。

static的成员变量只在类加载的时候会初始化一次，所以不存在线程安全问题。

然而，因为不是懒加载，如果构造的实例很庞大，构造完后又迟迟不适用，会造成资源的浪费。

※ 完美解法五：静态内部类

public class Singleton5 {

	private static class SingletonHolder {
		private static Singleton5 instance = new Singleton5();
	}

	private Singleton5() {
	}

	public static Singleton5 getInstance() {
		return SingletonHolder.instance;
	}
	
}

内部类SingletonHolder只在getInstance方法第一次调用的时候才会被加载,实现了懒加载；

static的内部类只会被加载一次，所以可以确保线程安全。