单例模式

核心

保证一个类只有一个对象，并且提供一个访问该类的全局访问点。

优点

• 减少系统性能开销，，对象的产生需要较多资源时，如配置文件读取，产生其他依赖对象，可在应用启动时直接产生一个单例对象，然后驻留内存。
• 可以优化共享资源的访问，如可以用一个单例类负责所有数据表的映射处理。

常见的五种实现方式

饿汉式(线程安全，调用效率高，但不能延时加载)

public class SingletonDemo {
    // 类初始化时，立即加载这个类，没有延时加载，线程安全
    private static SingletonDemo instance = new SingletonDemo();
    
    private SingletonDemo() {
        
    }
    
    public static SingletonDemo getIntance() {
        return instance;
    }

}

static变量在类装载时初始化，虚拟机保证只会装载一次类，肯定不会发生并发访问问题。

问题：若只是想加载类，而不是调用getInstance()，甚至永远没调用，就会造成资源的浪费。

懒汉式(线程安全，调用效率不高，可延时加载)

public class SingletonDemo {
    // 延时加载，真正调用时才创建对象
    private static SingletonDemo instance;
    
    private SingletonDemo() {
        
    }
    
    public static synchronized SingletonDemo getIntance() {
        if(instance == null) {
            instance = new SingletonDemo();
        }
        return instance;
    }

}

延迟加载，真正调用时才加载。资源利用率高。

问题：每次调用getInstance() 都要同步，并发效率低。

双重检测锁实现(JVM内部模型原因，有时会有问题，不建议使用)

public class SingletonDemo {

    private static SingletonDemo instance = null;
    
    private SingletonDemo() {
        
    }
    
    public static SingletonDemo getIntance() {
        if(instance == null) {
            SingletonDemo sc;
            synchronized (SingletonDemo.class) {
                sc = instance;
                if(sc == null) {
                    synchronized (SingletonDemo.class) {
                        if(sc == null) {
                            sc = new SingletonDemo();
                        }
                    }
                    instance = sc;
                }
            }
        }
        return instance;
    }

}

将同步内容放到if内部，不必每次调用时都同步，只有第一次才同步，提高了执行效率。

问题：由于编译器优化原因和JVM底层内部模型原因，有时会出现问题，不建议使用

静态内部类式(线程安全，调用效率高，且可延时加载)

public class SingletonDemo {
    
    private SingletonDemo() {
        
    }
    
    private static class SingletonClassInstance {
        private static final SingletonDemo instance = new SingletonDemo();  
    }
    
    private static SingletonDemo getInstance() {
        return SingletonClassInstance.instance;
    }
}

• 外部类没有static属性，则不会像饿汉式那样立即加载对象。
• 只有真正调用getInstance(),才会加载静态内部类。加载类时是线程 安全的。 instance是static final
  类型，保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全性.
• 兼备了并发高效调用和延迟加载的优势！

枚举单例(线程安全，调用效率高，但不能延时加载)

public enum SingletonDemo {
    
    INSTANCE; // 代表一个实例
    
    /**
     * 根据需要添加功能处理
     */
    public void  singletonOperation() {
        
    }
    
}

优点：

• 实现简单
• 枚举本身就是单例模式。由JVM从根本上提供保障！避免通过反射和反序列化的漏洞！

缺点：不能延时加载

如何选择

1. 对于单例对象需要占用资源少的，不需要延时加载，可选用枚举式和饿汉式，但枚举式优于饿汉式
2. 单例对象占用资源大的，需要延时加载的，可选用静态内部类式和懒汉式，且静态内部类式优于懒汉式。

防止反射和反序列化破解单例模式

反射和反序列化可以破解上述几种实现方式，除了枚举式外。下面是反破解方法

import java.io.ObjectStreamException;

public class SingletonDemo {
    private static SingletonDemo instance;
    /**
     * 防止反射破解单例模式
     */
    private SingletonDemo() {
        if(instance != null) {
             throw new RuntimeException();
        }
        
    }
    public static synchronized SingletonDemo getInstance() {
        if(instance == null) {
            instance = new SingletonDemo();
        }
        return instance;
    }
    /**
     * 防止反序列化破解单例模式
     */
    public Object readResolve() throws ObjectStreamException{
        return instance;
    }
    
}