GOF23设计模式之单例模式

/**
 * 饿汉式单例模式实现
 * 问题：如果只是加载本类，而不是要调用getInstance()，甚至永远没有调用，则会造成资源的浪费
 * @author XuZeSen
 *
 */
public class SingletonDemo1 {
	//类初始化时，立即加载这个对象(没有延时加载的优势)，静态变量加载是天然的线程安全
	private static SingletonDemo1 instance = new SingletonDemo1();
	//构造器私有化
	private SingletonDemo1() {
	}
	//定义一个全局的访问点，访问这个单例对象，方法没有同步，调用效率高
	public static SingletonDemo1 getInstance(){
		return instance;
	}	
}

/**
 * 懒汉式单例模式实现
 * 问题：资源利用率高了，但是，每次调用getInstance()方法都要同步，并发效率较低
 * @author XuZeSen
 *
 */
public class SingletonDemo2 {
	//类初始化时，没有立即加载这个对象(延时加载,真正用到的时候再创建)
	private static SingletonDemo2 instance;
	//构造器私有化
	private SingletonDemo2() {
	}
	//方法同步，调用效率低
	public static synchronized SingletonDemo2 getInstance(){
		if(null == instance){
			instance = new SingletonDemo2();
		}
		return instance;
	}	
}

/**
 * 双重检测锁实现
 * 这个模式下将内容同步到if内部，提高了执行的效率，不必每次获取对象时都进行同步
 * 只有第一次同步创建了
 * @author Sen
 *
 */
public class SingletonDemo3 {
	private static SingletonDemo3 instance = null;
	private SingletonDemo3() {
	}
	public static SingletonDemo3 getInstance(){
		if(null == instance){
			SingletonDemo3 temp;
			synchronized (SingletonDemo3.class) {
				temp = instance;
				if(null == temp){
					synchronized (SingletonDemo3.class) {
						temp  = new SingletonDemo3();
					}
				}
				instance = temp;
			}
		}
		return instance;
	}
}

/**
 * 静态内部类单例模式实现
 * 外部类没有static属性，则不会像饿汉式那样立即加载对象
 * 兼备了并发高效调用和延时加载的优势
 * @author XuZeSen
 *
 */
public class SingletonDemo4 {
	//构造器私有化
	private SingletonDemo4() {
	}
	//instance是static final类型，保证了内存中只有一个这样的实例存在，而且只能被赋值一次，从而保证了线程安全性
	private static class SingletonClassInatance{
		private static final SingletonDemo4 instance = new SingletonDemo4();
	}
	//只有真正调用getInstance()，才会加载静态内部类。加载类时是线程安全的。
	public static  SingletonDemo4 getInstance(){
		return SingletonClassInatance.instance;
	}	
}

/**
 * 枚举式单例模式实现（没有延时加载）
 * @author XuZeSen
 *
 */
public enum SingletonDemo5 {
	
	//这个枚举元素，本身就是单例对象
	INSTANCE;
	
	//添加自己需要的操作！
	public void singletonOperation(){
		
	}
}