单例设计模式

一、单例设计模式的介绍

单例设计模式属于三种设计模式类型（创建型、结构型、行为型）的创建型，顾名思义就是专门用来创建对象的一种设计模式。
所谓类的单例设计模式，就是采取一定的方法保证某个系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。
比如说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;
    }
}