单例模式各种实现方式的比较

一、饿汉式单例模式：

类型1：

/**
 * 饿汉式单例（可用）：使用静态常量，这会保证在类加载时
 * 就初始化一个A的实例，并且避免了线程安全问题。
 * 但是有可能该实例永远不会被用到而导致浪费内存。
 */
public class A {
	private static final A instance = new A();
	private A(){}
	public A getInstance(){
		return instance;
	}
}

类型2：

/**
 * 饿汉式单例模式（可用）：跟A类型，只不过初始化自身
 * 实例的过程改到静态块里面执行.
 */
public class B {
	private static final B instance;
	static{
		instance = new B();
	}
	private B(){}
	public B getIntance(){
		return instance;
	}
}

二、懒汉式单例模式：

类型1：

/**
 * 懒汉式单例模式（线程不安全，多线程不可用）：虽然解决了A、B
 * 两种方式浪费内存的缺点，但是该方式只适用于单线程，多线程下
 * 有个能出 现并发安全问题，导致创建多个实例。
 */
public class C {
	private static C instance;
	private C(){}
	public static C getInstance(){
		if(instance==null){
			instance = new C();
		}
		return instance;
	}
}

类型2：

/**
 * 懒汉式单例模式（同步方法，不推荐用）：解决了C中多线程并
 * 发安全问题，但是效率较低，每一个想要获取该类实例的线程
 * 都需要其他线程释放该方法对应的锁才能获取实例。
 */
public class D {
	private static D instance;
	private D(){}
	private synchronized static D getInstance(){
		if(instance==null){
			instance = new D();
		}
		return instance;
	}
}

类型3：

/**
 * 懒汉式单例模式（同步代码块，不可用）：虽然效率比D方式
 * 高，但是还是存在线程安全问题。
 */
public class E {
	private static E instance;
	private E(){}
	public static E getInstance(){
		if(instance==null){
			synchronized(E.class){
				instance = new E();
			}
		}
		return instance;
	}
}

类型4：

/**
 * 懒汉式单例模式(双重检查,推荐用):该方式既解决了饿汉式单例模式
 * 可能浪费内存空间的问题，有解决了线程安全的问题，并且效率比同
 * 步方法高。
 */
public class F {
	private static F instance;
	private F(){}
	public static F getInstance(){
		if(instance==null){
			synchronized(F.class){
				if(instance==null){
					instance = new F();
				}
			}
		}
		return instance;
	}
}

类型5：

/**
 * 静态内部类（推荐用）:整体实现是懒加载，但是里面具体的实现
 * 优势利用饿汉式加载的原来（利用类加载时实例化的方式避免
 * 了线程安全问题）。
 */
public class G {
	private G(){}
	private static class SingletonInstance{
		private static final G instance = new G();
	}
	public static G getInstance(){
		return SingletonInstance.instance;
	}
}