Java 单例模式

定义:保证程序运行时，让某个类在内存中只有一个对象，即让一个类只能创建一个对象

好处：有些实例，全局只需要一个就可以了，使用单例模式就可以防止一个全局使用的类，频繁的创建与销毁，导致耗费系统资源。

设计要素
1.一个私有静态变量 （确保只有一个实例）
2.一个私有构造函数 （确保只能单例类自己创建实例）
3.一个公有静态函数 （给使用者提供调用方法）

第一种：饿汉模式（线程安全）

public class Singleton1 {

    //创建当前类的对象
    private static Singleton1 s = new Singleton1();
    
    //构造方法私有化
    private Singleton1(){
    }
    
    //对外提供公共的访问方法将Singleton1对象暴露给外部
    public static Singleton1 getInstance(){
        return s;
    }
}

优点：提前实例化好了一个实例，避免了线程不安全问题的出现。
缺点：系统没有使用这个实例，或很久之后才需要这个实例，就会资源浪费。

第二种：懒汉模式
（如果方法没有synchronized，则线程不安全）

 public class Singleton2 {
    //创建当前类对象
    private static Singleton2 s= null;
    //构造方法私有化
    private Singleton2(){
    }
    //对外提供公共的访问方法将Singleton2对象暴露给外部
    public static synchronized Singleton2 getInstance(){
        if(s == null){
            s = new Singleton3();
        }
        return s;
    }
}

优点：延迟实例化，节约了资源，并且是线程安全的。
缺点：虽然解决了线程安全问题，但是性能降低了。因为，即使实例已经实例化了，既后续不会再出现线程安全问题了，但是锁还在，每次还是只能拿到锁的线程进入，使线程阻塞，等待时间过长。

第三种：双重检查锁 （线程安全）
（懒汉模式改良版）
（目的是为了减少同步的开销）

  public class Singleton3 {

    private volatile static Singleton3 s = null;
    
    private Singleton3(){
    }
    
    public static Singleton3 getInstance(){
        if(s == null){
            synchronized (Singleton3.class) {
                if(s == null){
                    s = new Singleton3();
                }
            }
        }
        return s;
    }
}

优点：延迟实例化，节约了资源；线程安全；并且相对于 线程安全的懒汉式，性能提高了。
缺点：volatile 关键字，对性能有一些影响。

第四种：静态内部类实现（线程安全）

  public class Singleton4 {
    
    private Singleton4(){
    }
    
    public static Singleton4 getInstance(){
        return SingletonFactory.s;
    }
    
    private static class SingletonFactory{
        private static Singleton4 s = new Singleton4();
    }
}

优点：延迟实例化，节约了资源；且线程安全；性能也提高了。

第五种 枚举类实现（线程安全）

public enum Singleton5 {
    //代表了Singleton5的一个实例
    INSTANCE; 
    //添加自己需要的操作 
    public void doSomeThing() {
     
    }
    
}

优点：写法简单，线程安全，天然防止反射和反序列化调用。

破坏单例模式的三种方式
反射
序列化
克隆

解决方案如下：
1、防止反射
定义一个全局变量，当第二次创建的时候抛出异常
2、防止序列化破坏
在被序列化的类中添加readResolve方法
3、防止克隆破坏
重写clone方法，返回原来的实例