设计模式 - 单例模式（二）六种写法

单例模式代码演进

懒汉式

package com.wang.c_singleton;
/**
 * <pre>
 * 单例模式 :  同时在内存中，只有一个对象存在。
 * 如何保证一个类在内存中只能有一个实例呢？
 *    1：构造私有 2：使用私有静态成员变量初始化本身对象 3：对外提供静态公共方法获取本身对象
 * 单例模式有两种实现方式： 1：懒汉式(延迟加载) 2：饿汉式
 * </pre>
 * 饿汉式 Singleton1
 * @author wangSong
 */
public class Singleton1 {
	/**
	 * 2：使用私有静态成员变量初始化本身对象
	 */
	private static Singleton1 instance = new Singleton1();
	/**
	 * 1：构造私有
	 */
	private Singleton1() {
	}
	/**
	 * 3：对外提供静态公共方法获取本身对象
	 * @return
	 */
	public static Singleton1 getInstacne() {
		return instance;
	}
}

恶汉式

 

package com.wang.c_singleton;
/**
 * <pre>
 * 单例实现之懒汉式实现
 * 思想：需要对象的时候，再去创建对象
 * 懒汉式设计模式，另一种叫法：延迟加载
 * 懒汉式单例模式步骤：
 * 	  1：构造私有 
 *    2：定义私有静态成员变量，先不初始化
 *    3：定义公开静态方法，获取本身对象
 *    	有对象就返回已有对象
 *    	没有对象，再去创建
 * 线程安全问题，判断依据：
 * 	  1：是否存在多线程	是  
 *    2：是否有共享数据	是
 *    3：是否存在非原子性操作	
 * 这个类可以满足基本要求，但是，懒汉式单例实现，存在线程安全隐患，如何解决？
 * 我们首先会想到对getInstance方法加synchronized关键字，SingletonFactory3
 * </pre>
 * @author wangSong
 */
public class Singleton2 {
	/**
	 * 2：定义私有静态成员变量，先不初始化
	 */
	private static Singleton2 instance = null;
	/**
	 * 1：构造私有
	 */
	private Singleton2() {
	}
	/**
	 * 3：定义公开静态方法，获取本身对象
	 * @return
	 */
	public static Singleton2 getInstance() {
		if (instance == null) {
			instance = new Singleton2();
		}
		return instance;
	}
}

package com.wang.c_singleton;
/**
 * <pre>
 * 		对getInstance方法加synchronized关键字
 *      synchronized关键字锁住的是这个对象，这样的用法，在性能上会有所下降
 *      因为每次调用getInstance()，都要对对象上锁
 *      事实上，只有在第一次创建对象的时候需要加锁，之后就不需要了
 *      所以，这个地方需要改进 Singleton4
 * </pre>
 * @author wangSong
 */
public class Singleton3 {
	private static Singleton3 instance = null;
	private Singleton3() {}
	/**
	 * <pre>
	 * 此处考验对synchronized知识点的掌握情况
	 * 线程安全，因为线程锁是在方法级别，导致执行效率低下，浪费资源
	 * </pre>
	 * @return
	 */
	public static synchronized Singleton3 getInstance() {
		if (instance == null) {
			instance = new Singleton3();
		}
		return instance;
	}
}

package com.wang.c_singleton;
/**
 * <pre>
 * 双重检查加锁
 * 似乎解决了之前提到的问题，将synchronized关键字加在了内部，也就是说当调用的时候是不需要加锁的，只有在instance为null，并创建对象的时候才需要加锁，性能有一定的提升。
 * 
 * 但是，这样的情况，还是有可能有问题的，看下面的情况：
 *    在Java指令中创建对象和赋值操作是分开进行的，也就是说instance = new Singleton();语句是分两步执行的。
 *    JVM并不保证这两个操作的先后顺序，也就是说有可能JVM会为新的Singleton实例分配空间，然后直接赋值给instance成员，然后再去初始化这个Singleton实例。
 * 这样就可能出错了，（理论错误，实际可能很难复现该场景）我们以A、B两个线程为例：
 *    a) A、B线程同时进入了第一个if判断
 *    b) A首先进入synchronized块，由于instance为null，所以它执行instance = new Singleton();
 *    c) 由于JVM内部的优化机制(指令重排序)，JVM先划分出一些分配给Singleton实例的空白内存，并赋值给instance成员（注意此时JVM没有开始初始化这个实例），然后A离开了synchronized块。
 *    d) B进入synchronized块，由于instance此时不是null，因此它马上离开了synchronized块并将结果返回给调用该方法的程序。
 *    e) 此时B线程打算使用Singleton实例，却发现它没有被初始化，于是错误发生了。
 * 所以程序还是有可能发生错误，其实程序在运行过程是很复杂的，从这点我们就可以看出，尤其是在写多线程环境下的程序更有难度，有挑战性。
 * </pre>
 * 我们对该程序做进一步优化：Singleton6
 * @author wangSong 
 */
public class Singleton4 {
	private static Singleton4 instance = null;
	private Singleton4() {}
	/**
	 * 双重检查加锁
	 * @return
	 */
	public static Singleton4 getInstance() {
		if (instance == null) {
			synchronized (Singleton4.class) {
				if (instance == null) {
					instance = new Singleton4();
				}
			}
		}
		return instance;
	}
}

package com.wang.c_singleton;
/**
 * 使用内部类来创建单例
 * @author wangSong
 */
public class Singleton5 {
	private Singleton5() {
	}
	/**
	 * 此处使用一个内部类来维护单例 JVM在类加载的时候，是互斥的，所以可以由此保证线程安全问题
	 * @author wangSong
	 */
	private static class Singleton5Factory {
		private static Singleton5 instance = new Singleton5();
	}
	/**
	 * 获取实例
	 * @return
	 */
	public static Singleton5 getInstance() {
		return Singleton5Factory.instance;
	}
}

package com.wang.c_singleton;
/**
 * 双重检查加锁 + volatile
 * volatile关键字的第一个作用：就是禁止被它修饰的变量相关操作进行指令重排序,保证有序性
 * volatile关键字的第二个作用：就是禁止工作内存使用，直接操作主内存,保证可见性
 * @author wangSong
 */
public class Singleton6 {
	private volatile static Singleton6 instance = null;
	private Singleton6() {}
	/**
	 * @return
	 */
	public static Singleton6 getInstance() {
		if (instance == null) {
			synchronized (Singleton6.class) {
				if (instance == null) {
					instance = new Singleton6();
				}
			}
		}
		return instance;
	}
}