单例模式

import java.io.Serializable;

/**
 * @ClassName Singleton
 * @Description
 * @Author Administrator
 * @Date 2022/5/20 19:49
 * @Version 1.0
 **/

//double check 懒汉式
// 反射能破坏此单例模式
public class Singleton implements Serializable{
    private Singleton(){}
    //volatile 防止  指令重排序

    // INSTANCE = new Singleton();
    // 此语句 容易发生 构造方法 与 赋值 出现指令重排序 ， 出现 先赋值为null 后 构造的情况
    private static volatile Singleton INSTANCE = null;

    private static Singleton getInstance(){
        if(INSTANCE != null){
            return INSTANCE;
        }

        synchronized (Singleton.class){

            //double check 防止首次创建对象时， 出现线程问题 ， 创建了两个实例对象
            if(INSTANCE != null){
                return INSTANCE;
            }
            INSTANCE = new Singleton();
            return INSTANCE;
        }
    }
    //防止反序列化
    public Object readResolve(){
        return INSTANCE;
    }
}

//防止反射破坏 单例模式 使用flag 标志位 标志只能调用一次构造方法
class Singleton2 implements Serializable{
    private static boolean flag = false;//如果之前调用过构造方法了 ， 则 第二次调用flag = true
    private static volatile Singleton2 INSTANCE = null;
    private Singleton2(){
        if(!flag){//第一次创建时进入 并修改 flag = true;
            flag = true;
        }else{
            throw new RuntimeException("使用反射破坏单例时无效的哦！");
        }
    }
    public static Singleton2 getInstance(){
        if(INSTANCE != null){
            return INSTANCE;
        }
        synchronized (Singleton2.class){
            if(INSTANCE != null){
                return INSTANCE;
            }
            INSTANCE = new Singleton2();
            return INSTANCE;
        }
    }
    //防止反序列化破坏单例
    public Object readResolve(){
        return INSTANCE;
    }
}

/*
使用枚举类
enum Singleton{
    enum INSTANCE;
}

* */

//饿汉式创建
final class Singleton1 implements Serializable {
    private static boolean flag = false;
    private Singleton1(){
        if(!flag){
            flag = true;
        }else{
            throw new RuntimeException("别想使用反射破坏单例模式哦！");
        }
    }
    //此处随着类加载而加载 所以是线程安全的
    private static final Singleton1 INSTANCE = new Singleton1();

    public static Singleton1 getInstance(){
        return INSTANCE;
    }

    //防止反序列化破坏单例
    public Object readResolve(){
        return INSTANCE;

    }


//使用静态内部类 懒汉式创建 推荐
final class Singleton3 implements Serializable{
    private static boolean flag = false;
    private Singleton3(){
        if(!flag){
            flag = true;
        }else{
            throw new RuntimeException("别想使用反射破坏单例模式");
        }
    }

    private static class LazyHolder{
        static final Singleton3 INSTANCE = new Singleton3();
    }
    public static Singleton3 getInstance(){
        return LazyHolder.INSTANCE;
    }
    public Object readResolve(){
        return LazyHolder.INSTANCE;
    }
}








}