单例模式

定义

单例模式（SingletonPattern）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建型模式。

饿汉式

优点：没有加任何的锁、执行效率比较高，在用户体验上来说，比懒汉式更好。

缺点：类加载的时候就初始化，不管用与不用都占着空间，浪费了内存，有可能占着茅坑不拉屎。

 public class Singleton01 {
 
     private Singleton01() {
     }
 
     private static final Singleton01 instance = new Singleton01();
 
     public static Singleton01 getInstance() {
         return instance;
     }
 }

懒汉式

dcl（双重检查）

 public class Singleton02 {
 
     private Singleton02() {
     }
 
     // 禁止指令重排序
     private volatile static Singleton02 instance = null;
     // 双重检查
     private static Singleton02 getInstance() {
         if(instance == null){
             synchronized (Singleton01.class){
                 if(instance == null){
                     instance = new Singleton02();
                 }
             }
         }
         return instance;
     }
 }

静态内部类

静态内部类在外部类加载的时候不会被加载，只有外部类中用到内部类时候才会被加载
由于静态内部类没有使用任何锁机制，所以性能优于双重检查实现方式。

 public class Singleton03 {
 
     private Singleton03() {
     }
 
     public static Singleton03 getInstance(){
         return Singleton03Holder.lazy;
     }
     // 静态内部类
     private static class Singleton03Holder {
         public final static Singleton03 lazy = new Singleton03();
     }
 }

枚举单例

jvm判断了枚举无法反射获取对象，无法序列化，防止了反射破坏单例和序列化破坏单例

 public enum SingletonEnum {
 
     INSTANCE;
 
     private Object data = new Object();
 
     public Object getData(){
         return data;
     }
 
     public static SingletonEnum getInstance(){
         return INSTANCE;
     }
 }

ThreadLocal在线程内实现单例

使用ThreadLocal动态切换数据源

反射破坏单例以及解决方案

以上三种单例的写法已经很完善了，但是挡不住反射创建对象，调用者反射破坏单例

public class ReflectBlockSingleton {
 
     /**
      * 反射破坏单例
      * @param args
      */
     public static void main(String[] args) {
         Class<Singleton01> clazz = Singleton01.class;
         try {
             Constructor<Singleton01> constructor = clazz.getDeclaredConstructor(null);
             constructor.setAccessible(true);//强吻
             Singleton01 s1 = constructor.newInstance();
             Singleton01 s2 = Singleton01.getInstance();
             System.out.println(s1 == s2); // false
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 }

解决方案：在私有构造方法中增加判断

private Singleton01() {         if(instance != null){
             throw new RuntimeException("实例已经创建！");
         }
     }

序列化破坏单例以及解决方案

将单例实例创建出来后，序列化到一个文件中，再读出来反序列化为对象

public class SeriableBlockSingletonTest {
     public static void main(String[] args) {
 
         Singleton01 s1 = null;
         Singleton01 s2 = Singleton01.getInstance();
 
         FileOutputStream fos = null;
         try {
             fos = new FileOutputStream("SeriableSingleton.obj");
             ObjectOutputStream oos = new ObjectOutputStream(fos);
             oos.writeObject(s2);
             oos.flush();
             oos.close();
 
 
             FileInputStream fis = new FileInputStream("SeriableSingleton.obj");
             ObjectInputStream ois = new ObjectInputStream(fis);
             s1 = (Singleton01)ois.readObject();
             ois.close();
 
             System.out.println(s1);
             System.out.println(s2);
             System.out.println(s1 == s2);
 
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 }
 解决方案
 增加readResolve方法，还是创建了两次对象，只不过在jvm层面被覆盖了。反序列化出来的对象会被GC回收
     
     public class Singleton01 implements Serializable {
 
     private Singleton01() {
         if(instance != null){
             throw new RuntimeException("实例已经创建！");
         }
     }
 
     private static final Singleton01 instance = new Singleton01();
 
     public static Singleton01 getInstance() {
         return instance;
     }
 
     private Object readResolve(){
         return instance;
     }
 
 
 }

单例模式总结

优点：

内存只有一个实例，减少了内存开销

可以避免对资源的多重占用

设置全局访问点，严格控制访问
缺点

没有接口，扩展困难

如果要扩展单例对象，只能修改代码，没有其他途径，不符合开闭原则