设计模式之如何正确地写出单例模式 （一）

原文链接： https://www.cnblogs.com/Qian123/p/5729172.html

参考链接：http://wuchong.me/blog/2014/08/28/how-to-correctly-write-singleton-pattern/ 与

https://www.cnblogs.com/Qian123/p/5729172.html

总结：

/*只有在要明确实现 lazy loading 效果时，才会使用第 2 种登记方式（饿汉式）。正常情况下，使用第一种饿汉式即可*/

package com.ly.designPattern;

//饿汉式，现场安全，缺点是：不是一种懒加载模式(类加载时就初始化，浪费内存)
public class SingletonE {
	//类加载时就初始化
	private static final SingletonE instance = new SingletonE();
	
	//私有构造器
	private SingletonE(){}
	
	public static SingletonE getInstance(){
		return instance;
	}
}
/**这种方法非常简单，因为单例的实例被声明成 static 和 final 变量了，在第一次加载类到内存中时就会初始化，所以创建实例本身是线程安全的。*/
/**缺点是它不是一种懒加载模式（lazy initialization），单例会在加载类后一开始就被初始化，即使客户端没有调用 getInstance()方法。
 * 饿汉式的创建方式在一些场景中将无法使用：譬如 Singleton 实例的创建是依赖参数或者配置文件的，
 * 在 getInstance() 之前必须调用某个方法设置参数给它，那样这种单例写法就无法使用了。*/ 

/**描述：这种方式比较常用，但容易产生垃圾对象。
优点：基于 classloder 机制避免了多线程的同步问题,没有加锁，执行效率会提高。
缺点：不是一种懒加载模式,类加载时就初始化，浪费内存*/
//------------------------------优化1 静态内部类 static nested class---------------------------------------------------
//登记式/静态内部类
class SingletonE2 {
	private static class SingletonHolder {
		private static final SingletonE2 instance = new SingletonE2();
	}
	
	//私有构造器
	private SingletonE2(){}
	
	public static SingletonE2 getInstance(){
		return SingletonHolder.instance;
	}
}

/**描述：这种方式能达到双检锁方式一样的功效，但实现更简单。
 * 对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。

这种方式同样利用了 classloder 机制来保证初始化 instance 时只有一个线程，它跟上面不同的是：上面方式只要 Singleton 类被装载了，
那么 instance 就会被实例化（没有达到 lazy loading 效果），
而这种方式是 Singleton 类被装载了，instance 不一定被初始化。
因为 SingletonHolder 类没有被主动使用，只有显示通过调用 getInstance 方法时，才会显示装载 SingletonHolder 类，从而实例化 instance。
想象一下，如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在 Singleton 类加载时就实例化，
因为不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比上面方式就显得很合理。*/

/**这种写法仍然使用JVM本身机制保证了线程安全问题；由于 SingletonHolder 是私有的，除了 getInstance() 之外没有办法访问它，因此它是懒汉式的；
 * 同时读取实例的时候不会进行同步，没有性能缺陷；也不依赖 JDK 版本。*/

/////////////////////////////////////////////////总结//////////////////////
/*只有在要明确实现 lazy loading 效果时，才会使用第 2 种登记方式。正常情况下，使用第一种饿汉式即可*/

以下是懒汉式：

package com.ly.designPattern;

//懒汉式，线程不安全
public class Singleton {
	private static Singleton instance;
	
	//私有构造器
	private Singleton(){}
	
	public static Singleton getInstance(){
		if(instance == null){
			instance = new Singleton();
		}
		return instance;
	}
}
/**当有多个线程并行调用 getInstance() 的时候，就会创建多个实例。也就是说在多线程下不能正常工作。*/
//------------------------------优化1---------------------------------------------------
//懒汉式，线程安全           //同步（synchronized）
class Singleton2 {
	private static Singleton2 instance;
	
	//私有构造器
	private Singleton2(){}
	
	public static synchronized Singleton2 getInstance(){
		if(instance == null){
			instance = new Singleton2();
		}
		return instance;
	}
}
/**虽然做到了线程安全，并且解决了多实例的问题，但是它并不高效。
 * 因为在任何时候只能有一个线程调用 getInstance() 方法。
 * 但是同步操作只需要在第一次调用时才被需要(即if语句中判断 instance 为null时才调用，不为null时是直接返回instance的)，
 * 即第一次创建单例实例对象时。这就引出了双重检验锁。
 */
//------------------------------优化2---------------------------------------------------
//双检锁/双重校验锁（DCL，即 double-checked locking），使用同步块加锁的方法
class Singleton3 {
	private volatile static Singleton3 instance;//声明成 volatile adj易变的; 无定性的; 
	
	//私有构造器
	private Singleton3(){}
	
	public static Singleton3 getInstance(){
		if(instance == null){					//Single Checked
			synchronized(Singleton3.class ){
				if(instance == null){		    //Double Checked
					instance = new Singleton3();
				}
			}
		}
		return instance;
	}
}
/**为什么在同步块内还要再检验一次？因为可能会有多个线程一起进入同步块外的 if，如果在同步块内不进行二次检验的话就会生成多个实例了。*/

/**这段代码看起来很完美，很可惜，它是有问题。主要在于instance = new Singleton()这句，这并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情。
1、给 instance 分配内存
2、调用 Singleton 的构造函数来初始化成员变量
3、将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了）
但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。
如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。
我们只需要将 instance 变量声明成 volatile 就可以了。*/

/**使用 volatile 的主要原因是其一个特性：禁止指令重排序优化。
 * 也就是说，在 volatile 变量的赋值操作后面会有一个内存屏障（生成的汇编代码上），读操作不会被重排序到内存屏障之前。
 * 比如上面的例子，取操作必须在执行完 1-2-3 之后或者 1-3-2 之后，不存在执行到 1-3 然后取到值的情况。
 * 从「先行发生原则」的角度理解的话，就是对于一个 volatile 变量的写操作都先行发生于后面对这个变量的读操作（这里的“后面”是时间上的先后顺序）。


但是特别注意在 Java 5 以前的版本使用了 volatile 的双检锁还是有问题的。
其原因是 Java 5 以前的 JMM （Java 内存模型）是存在缺陷的，即时将变量声明成 volatile 也不能完全避免重排序，
主要是 volatile 变量前后的代码仍然存在重排序问题。这个 volatile 屏蔽重排序的问题在 Java 5 中才得以修复，所以在这之后才可以放心使用 volatile。


* 相信你不会喜欢这种复杂又隐含问题的方式，当然我们有更好的实现线程安全的单例模式的办法。即饿汉式*/