Head First 设计模式笔记 4.单例模式

单例模式比较简单，用于创建全局唯一的一个对象。这里直接贴出它的定义

单例模式保证一个类仅有一个实例，并提供一个访问它的全局访问点。

有什么用呢？很多对象只有一个，比如任务管理器，文件。假如有好几个对象，就会出现BUG。

那么，利用全局静态变量实现单一对象如何呢？

• 全局静态变量确实能够保证全局访问，但是无法保证全局只有一个对象
• 假如直接赋值给一个全局变量，就意味着要在一开始就初始化它，如果它很大，然而运行过程中又没有使用到，就会导致空间的浪费。

单例模式的实现

将构造函数访问设计为private会怎么样？如下代码所示

public class Myclass{
	private Myclass(){};
}

这个类能否被实例化呢？

很明显做不到，因为它的构造函数被设为private的，也就是说只有该类的实例才能调用它，然而不用构造函数又无法实例化对象。

我们再加入一个静态函数，用于调用这个构造函数。

public class Myclass{
	private Myclass(){}
	public static Myclass getInstance(){
		return new Myclass();
	}
}

这样就可以实例化该类了，再稍作修改，就可以得到一个只能被实例化一次的类。

懒汉式，线程不安全

// NOTE: This is not thread safe!

public class Singleton {
	private static Singleton uniqueInstance;
 	//私有化的构造函数，保证它不会被实例化
	private Singleton() {}
 
	public static Singleton getInstance() {
		if (uniqueInstance == null) {
			uniqueInstance = new Singleton();
		}
		return uniqueInstance;
	}
}

然而这么做并非线程安全的。当多个线程访问getInstance()方法时，就可能会实例化出多个对象。

懒汉式，线程安全

一个粗暴的解决方法，我们给getInstance()方法加上synchronized关键字。

public class Singleton {
	private static Singleton uniqueInstance;
 	//私有化的构造函数，保证它不会被实例化
	private Singleton() {}
 
	public static synchronized Singleton getInstance() {
		if (uniqueInstance == null) {
			uniqueInstance = new Singleton();
		}
		return uniqueInstance;
	}
}

然而，实际上我们只需要在第一次调用getInstance()才需要同步，这样加上同步后会引入不必要的效率降低。假如getInstance()方法需要被频繁地调用，那么会大大降低效率。

饿汉式，线程安全

假如创建一个对象的消耗不大的话，我们可以考虑直接在初始化的时候实例化对象。如下所示

public class Singleton {
	private static Singleton uniqueInstance = new Singleton(); 
 	//私有化的构造函数，保证它不会被实例化
	private Singleton() {}
 
	public static Singleton getInstance() {
		return uniqueInstance;
	}
}

这种在初始化时直接实例化单例的实现方式，我们叫它“饿汉式”，主要用于对象被频繁创建并且创建消耗不大的情况。与之对应的前面的直到使用才创建单件的实现方式称为“懒汉式”。

双检锁/双重校验锁

那么当单例创建消耗比较大，而且可能需要创建频繁，也可能不会被创建，该怎么办呢？用synchronized修饰方法会由于同步造成不必要的性能下降，用饿汉式创建方式又会让初始化就实例化对象，而这个对象可能从未被实例化。

双检锁/双重校验锁可以帮助我们解决这个问题。我们可以先检查对象是否被创建，如果没有被创建，我们才进行同步。

//
// Danger!  This implementation of Singleton not
// guaranteed to work prior to Java 5
//

public class Singleton {
	private volatile static Singleton uniqueInstance;
 	// volatile确保当uniqueInstance被实例化，线程访问它是线程安全的
	private Singleton() {}
 
	public static Singleton getInstance() {
		if (uniqueInstance == null) {
		// 假如单件为空，才会对整个类进行加锁
			synchronized (Singleton.class) {
				if (uniqueInstance == null) {
					uniqueInstance = new Singleton();
				}
			}
		}
		return uniqueInstance;
	}
}

很巧妙的方法，遗憾的是在1.4版本以前的Java版本中，不支持volatile修饰字。所以用的时候注意Java的版本。

单例模式的黑暗面

使用单例模式的类是无法被继承的，因为它的构造函数是private修饰的，无法被扩展。然而将privata改为protected又会破坏单例模式，别的类也可以实例化它了。假如一个设计大量使用了单价模式，那么很有可能是有问题的。因为一般情况下它的使用场合不多。