设计模式-简述单例模式

单例模式

​ 单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例，主要是为了避免不一致状态。

单例模式的特点

• 单例类只能有一个实例。
• 单例类必须自己创建自己的唯一实例。
• 单例类必须给所有其他对象提供这一实例。

单例模式保证了全局对象的唯一性，比如系统启动读取配置文件就需要单例保证配置的一致性。

单例的四大原则

• 构造私有
• 以静态方法或者枚举返回实例
• 确保实例只有一个，尤其是多线程环境
• 确保反序列化时不会重新构建对象

实现单例模式的方式

饿汉式（立即加载）

​ 饿汉式单例在类加载初始化时就创建好一个静态的对象供外部使用，除非系统重启，这个对象不会改变，所以本身就是线程安全的。

​ Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问。（事实上，通过Java反射机制是能够实例化构造方法为private的类的，会使Java单例实现失效）

public class Singleton {  
  
    /** 
     * 私有构造 
     */  
    private Singleton() {  
        System.out.println("构造函数Singleton1");  
    }  
  
    /** 
     * 初始值为实例对象 
     */  
    private static Singleton single = new Singleton();  
  
    /** 
     * 静态工厂方法 
     * @return 单例对象 
     */  
    public static Singleton getInstance() {  
        System.out.println("getInstance");  
        return single;  
    }  
  
    public static void main(String[] args){  
        System.out.println("初始化");  
        Singleton instance = Singleton.getInstance();  
    }  
}  

懒汉式（延迟加载）

使用双重检查锁，保证多线程不会产生多个Singleton对象

public class Singleton4 {  
  
    /** 
     * 私有构造 
     */  
    private Singleton4() {}  
  
    /** 
     * 初始值为null 
     * 加volatile关键字是为了防止 创建对象时的指令重排问题，导致其他线程使用对象时造成空指针问题。
     */  
    Private volatile static Singleton4 single = null;  
  
    /** 
     * 双重检查锁 
     * @return 单例对象 
     */  
    public static Singleton4 getInstance() {  
        if (single == null) {  
            synchronized (Singleton4.class) {  
                if (single == null) {  
                    single = new Singleton4();  
                }  
            }  
        }  
        return single;  
    }  
}

静态内部类

​ 这种方式引入了一个内部静态类（static class），静态内部类只有在调用时才会加载，它保证了Singleton 实例的延迟初始化，又保证了实例的唯一性。

​ 静态内部类虽然保证了单例在多线程并发下的线程安全性，但是在遇到序列化对象时，默认的方式运行得到的结果就是多例的。

public class Singleton5 {  
  
    /** 
     * 私有构造 
     */  
    private Singleton5() {}  
  
    /** 
     * 静态内部类 
     */  
    private static class InnerObject{  
        private static Singleton5 single = new Singleton5();  
    }  
  
    public static Singleton5 getInstance() {  
        return InnerObject.single;  
    }  
} 

内部枚举类实现

​ 事实上，通过Java反射机制是能够实例化构造方法为private的类的。这也就是我们现在需要引入的枚举单例模式。主要为了防止反射和反序列化攻击。

public class SingletonFactory {  
  
    /** 
     * 内部枚举类 
     */  
    private enum EnumSingleton{  
        Singleton;  
        private Singleton6 singleton;  
  
        //枚举类的构造方法在类加载是被实例化  
        private EnumSingleton(){  
            singleton = new Singleton6();  
        }  
        public Singleton6 getInstance(){  
            return singleton;  
        }  
    }  
      
    public static Singleton6 getInstance() {  
        return EnumSingleton.Singleton.getInstance();  
    }  
}  
  
class Singleton6 {  
    public Singleton6(){}  
}