单例设计模式
一、单例设计模式的介绍
单例设计模式属于三种设计模式类型（创建型、结构型、行为型）的创建型，顾名思义就是专门用来创建对象的一种设计模式。
所谓类的单例设计模式，就是采取一定的方法保证某个系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。
比如说Hebernate的SessionFactory，它充当数据存储源的代理，并负责创建Session对象，SessionFactory并不是轻量级的，所以一般一个项目系统只需要一个SessionFactory就够了，这个时候就可以利用单例设计模式了。
二、实现单例设计模式的七种方式及演变
1.饿汉式（静态常量）
//饿汉式(静态变量)
/*
1.构造器必须私有化（防止new）
2.类的内部创建对象
3.向外暴露一个静态的公共方法getInstance
*/
public class Singleton {
//1. 构造器私有化, 外部能new
private Singleton() {
}
//2.本类内部创建对象实例
private final static Singleton instance = new Singleton();
//3. 提供一个公有的静态方法，返回实例对象
public static Singleton getInstance() {
return instance;
}
}
优缺点：
- 优点：这种写法在类加载的时候就可以完成对象的实例化，避免了线程同步的问题
- 缺点：类装载就完成实例化，肯定会造成内存浪费问题
2.饿汉式（静态代码块）
//饿汉式(静态变量)
public class Singleton {
private static Singleton instance;
//1. 构造器私有化, 外部能new
private Singleton() {
}
//2.本类内部创建对象实例
static { // 在静态代码块中，创建单例对象
instance = new Singleton();
}
//3. 提供一个公有的静态方法，返回实例对象
public static Singleton getInstance() {
return instance;
}
}
优缺点：
- 优点：这种写法和上面的写法类似，只不过将类实例化的过程放在静态代码块中，其实也是在类加载的时候，就执行静态代码块中的代码，初始化类的实例，所以优点与上面一致。
- 缺点：类装载就完成实例化，肯定会造成内存浪费问题
3.懒汉式（线程不安全）
public class Singleton {
private static Singleton instance;
private Singleton() {}
//提供一个静态的公有方法，当使用到该方法时，才去创建 instance
//即懒汉式
public static Singleton getInstance() {
if(instance == null) {
instance = new Singleton();
}
return instance;
}
}
优缺点：
- 优点：这种方法可以实现懒加载（真正要是用的时候才去新建对象），但是只能在单线程的情况下使用。
- 缺点：多线程条件下，一个线程进入了if(instance == null) 的判断，但是还没有开始往下执行，另外一个线程也通过了这个判断，这时候就会产生多个实例，多线程环境下这种方式不可取，实际开发过程中不能使用该方式
4.懒汉式（同步方法实现线程安全）
// 懒汉式(线程安全，同步方法)
public class Singleton {
private static Singleton instance;
private Singleton() {}
//提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
//即懒汉式
public static synchronized Singleton getInstance() {
if(instance == null) {
instance = new Singleton();
}
return instance;
}
}
优缺点：
- 优点：可实现懒加载、解决了线程安全问题。
- 缺点：每个线程在想获取实例的时候，都要先进入同步方法，然后再执行实例化逻辑 ，这样效率太低
5.懒汉式（同步代码块实现线程安全）
/ 懒汉式(线程安全，同步代码块)
public class Singleton {
private static Singleton instance;
private Singleton() {
}
//提供一个静态的公有方法，加入双重检查代码，解决线程安全问题, 同时解决懒加载问题
//同时保证了效率, 推荐使用
public static Singleton getInstance() {
if(instance == null) {
synchronized (Singleton.class) {
instance = new Singleton();
}
}
return instance;
}
}
优缺点：
- 优点：该方式本意是对第四种方式的改进，想要减小同步控制范围来提升效率。
- 缺点：但是这种同步并不能起到线程同步的作用，跟第三种实现方式一样，假如一个线程进入了if(singleton == null)
判断，另外一个线程也通过了这个判断，同样会出现创建多个实例的情况，实际开发不能使用这种方式
6.懒汉式（双重检查实现）实际开发中推荐使用
// 懒汉式(线程安全，同步方法)
public class Singleton {
private static volatile Singleton instance;
private Singleton() {}
//提供一个静态的公有方法，加入双重检查代码，解决线程安全问题, 同时解决懒加载问题
//同时保证了效率, 推荐使用
public static Singleton getInstance() {
if(instance == null) {
synchronized (Singleton.class) {
if(instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
优缺点：
- 优点：该方式本意是对第五种方式的改进，在减小同步控制范围来提升效率，的同时同步代码块内部再进行一次判空，从而解决同步问题。
还有一个重要的点：对象属性前应使用volatile修饰，防止指令重排带来的同步问题，这是前面五种方式没有考虑到的。- 推荐实际开发使用该方式
7.懒汉式（静态内类实现）实际开发中推荐使用
// 静态内部类完成， 推荐使用
public class Singleton {
//构造器私有化
private Singleton() {}
//写一个静态内部类,该类中有一个静态属性 Singleton
private static class SingletonInstance {
private static final Singleton INSTANCE = new Singleton();
}
//提供一个静态的公有方法，直接返回SingletonInstance.INSTANCE
public static Singleton getInstance() {
return SingletonInstance.INSTANCE;
}
}
优缺点：
- 优点：这种方式采用了类的加载机来保证初始化实例时只有一个线程，静态内部类方式在Singleton类被加载时不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。
类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。从而避免了线程不安全，而且效率高。- 推荐实际开发使用该方式
三、如何防止反射破坏单例设计模式
由于可以通过反射调用无参构造方法生成新的对象从而破坏单例性，所以可以在构造方法这加入条件判断，防止反射破坏单例。
1.懒汉式（双重检查实现）增加防反射破坏单例性的功能
// 懒汉式(线程安全，同步方法)
public class Singleton {
private static volatile Singleton instance;
private Singleton() {
// 由于反射调用无参构造方法会生成新的对象从而破坏单例性，所以可以在构造方法这加入条件判断，防止反射破坏单例
if(instance != null) {
throw new RuntimeException();
}
}
//提供一个静态的公有方法，加入双重检查代码，解决线程安全问题, 同时解决懒加载问题
//同时保证了效率, 推荐使用
public static Singleton getInstance() {
if(instance == null) {
synchronized (Singleton.class) {
if(instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
3.懒汉式（静态内类实现）增加防反射破坏单例性的功能
// 静态内部类完成， 推荐使用
public class Singleton {
private static boolean flag = false;// 增加判断标志，
private Singleton() {
// 首次利用构造方法创建Singleton对象，标志为false，不会抛异常；但是已经调用过一次构造方法了，flag就会为true会抛出异常
synchronized (Singleton.class) {
if (flag){
throw new RuntimeException();
}
flag = true;
}
}
//写一个静态内部类,该类中有一个静态属性 Singleton
private static class SingletonInstance {
private static final Singleton INSTANCE = new Singleton();
}
//提供一个静态的公有方法，直接返回SingletonInstance.INSTANCE
public static Singleton getInstance() {
return SingletonInstance.INSTANCE;
}
}
