设计模式之单例模式

一、单例模式

1.1 饿汉式

• 无须考虑多个线程同时访问的问题；调用速度和反应时间优于懒汉式单例；
• 资源利用效率不及懒汉式单例；
• 系统加载时间可能会比较长。

// 饿汉式
public class EagerSingleton {

	// 类加载时，就创建对象（进行资源分配）
	private static EagerSingleton instance = new EagerSingleton();
	
	private EagerSingleton() {
	}
	
	/**
	 * 性能比懒汉式好一些
	 *
	 * @return
	 */
	public static EagerSingleton getInstance() {
		return instance;
	}
}

1.2 懒汉式

1.2.1 多线程不安全

package design.singleton;

/**
 * 类是模板，用来创建多个实例（对象）；
 * 有时希望只能创建出一个唯一的实例
 * 单例模式
 *
 */

//懒汉式 - 延迟加载
public class LazySingleton {

	// 类变量，类加载时创建的唯一的一份
	private static LazySingleton instance = null;
	
	// 封装在内部的状态或方法，它们也是 全局唯一 的
	int count;
	
	// 构造方法 私有，外部不可调用
	private LazySingleton() {
		count = 0;
	}
	
	public void add() {
		++count;
	}
	
	public int count() {
		return count;
	}
	
	/*
	 * 公共的静态方法，通过类名调用
	 * 多线程时需要加上同步关键字 synchronized ！！！
	 */
	public static LazySingleton getInstance() {
		if(instance==null) {
			// 第一次调用时，创建对象，延迟了资源加载时间
			// 需要较长时间
			// 考虑如果多个对象同时访问将导致创建多个实例对象，how to do？
			instance = new LazySingleton();
		}
		return instance;
	}
	
}

1.2.2 同步锁：锁方法

public class LazySingletonLock1 {

	private static LazySingletonLock1 instance = null;
	
	private LazySingletonLock1() {
	}
	
	// 同步关键字 synchronized
	// 锁方法
	public static synchronized LazySingletonLock1 getInstance() {
		if(instance==null) {
			instance = new LazySingletonLock1();
		}
		return instance;
	}
}

1.2.3 同步锁：锁代码段

public class LazySingletonLock2 {

	private static LazySingletonLock2 instance = null;
	
	private LazySingletonLock2() {
	}
	
	// 同步关键字 synchronized
	public static LazySingletonLock2 getInstance() {
		if(instance==null) {
			// 锁代码段
			synchronized(LazySingletonLock2.class) {
				instance = new LazySingletonLock2();
			}
		}
		return instance;
	}
}

1.2.4 双重检查锁

public class LazySingletonDoubleCheckLock {

	// volatile 关键字 ：1、多线程之间可见性；2、禁止指令重排序。
	private volatile static LazySingletonDoubleCheckLock instance = null;
	
	private LazySingletonDoubleCheckLock() {
	}
	
	// 双重检查锁
	public static LazySingletonDoubleCheckLock getInstance() {
		//第一重判断
		if(instance==null) {
			// 锁代码段
			synchronized(LazySingletonDoubleCheckLock.class) {
				// 第二重判断
				if(instance==null) {
					// 创建单例实例
					instance = new LazySingletonDoubleCheckLock();					
				}
			}
		}
		return instance;
	}
}

1.3 基于静态内部类

// 方案三：基于静态内部类
// 发起人：Crazy Bob（Bob Lee）
// 静态内部类不会在单例加载时就加载，而是在调用getInstance()方法时才进行加载，达到了类似懒汉模式的效果，而这种方法又是线程安全的
public class Singleton3 {

	public static class SingletonHolder{
		private static Singleton3 instance = new Singleton3();
	}
	
	private Singleton3() {
	}
	
	public static Singleton3 getInstance() {
		return SingletonHolder.instance;
	}

}