【设计模式】- 单例模式

1、饿汉式

//饿汉式单例:一进来就会创建对象，可能会浪费时间
public class Hungry {

    private Hungry(){

    }
	//创建对象
    public final static Hungry hungry = new Hungry();

    public static Hungry getHungry(){
        return hungry;
    }
}

2、懒汉式

1）基本的懒汉式

//懒汉式单例
public class Lazy {

    private Lazy(){
       System.out.println(Thread.currentThread().getName() + "lazy线程启动");
	}
        
	if (lazy!=null){
		throw new RuntimeException("不要试图用凡是破坏单例！");
	}
       
    private static Lazy lazy;

    public static Lazy getLazy(){
		if (lazy==null){
		lazy = new Lazy(); 
	}
        return lazy; 
    }

    //单线程下，没有问题，但是多线程会存在问题
	public static void main(String[] args) {
		for (int i = 0; i < 10; i++) {
			new Thread(()->{
				lazy.getLazy();
			}).start();
		}
	}
}

2）解决多线程不安全加双重检测锁

//懒汉式单例
public class Lazy {

    private Lazy(){
		System.out.println(Thread.currentThread().getName() + "lazy线程启动");
   }

    private static Lazy lazy;

    public static Lazy getLazy(){
        //双重检测锁模式，懒汉式，DCL懒汉式
        if (lazy==null){
            synchronized (Lazy.class){
                if (lazy==null){
                    lazy = new Lazy(); 
                }
            }
        }
        return lazy; //此时lazy会有可能未构造
    }

    //单线程下，没有问题，但是多线程会存在问题
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                lazy.getLazy();
            }).start();
        }
    }
}

3）针对懒汉式在创建对象时，不是原子性操作，避免指令重排，将属性定义为volatile类型（双重检测锁＋原子操作）

//懒汉式单例
public class Lazy {

    private Lazy(){
		System.out.println(Thread.currentThread().getName() + "lazy线程启动");
   }

    private volatile static Lazy lazy;

    public static Lazy getLazy(){
        //双重检测锁模式，懒汉式，DCL懒汉式
        if (lazy==null){
            synchronized (Lazy.class){
                if (lazy==null){
                    lazy = new Lazy(); //不是原子性操作，会发生指令重排现象，期望1-2-3
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     * 123
                     * 132 A
                     *     B //此时lazy还没有构造，就返回了
                     *
                     * 所以避免指令重排，要加volatile(原子性操作)
                     */
                }
            }
        }
        return lazy; //此时lazy会有可能未构造
    }

    //单线程下，没有问题，但是多线程会存在问题
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                lazy.getLazy();
            }).start();
        }
    }
}

4）初步解决反射破坏懒汉式（三重检测）

//懒汉式单例
//道高一尺魔高一丈
public class Lazy {

    private Lazy(){

        synchronized (Lazy.class){
			if (lazy!=null){
				throw new RuntimeException("不要试图用凡是破坏单例！");
			}
		}
    }

    private volatile static Lazy lazy;

    public static Lazy getLazy(){
        //双重检测锁模式，懒汉式，DCL懒汉式
        if (lazy==null){
            synchronized (Lazy.class){
                if (lazy==null){
                    lazy = new Lazy(); //不是原子性操作，会发生指令重排现象，期望1-2-3
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     * 123
                     * 132 A
                     *     B //此时lazy还没有构造，就返回了
                     *
                     * 所以避免指令重排，要加volatile(原子性操作)
                     */
                }
            }
        }
        return lazy; //此时lazy会有可能未构造
    }
    
    //反射
    public static void main(String[] args) throws Exception {

        Lazy instant = lazy.getLazy(); //懒汉式中拿到的对象

        Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor(null);//反射获取无参构造器
        declaredConstructor.setAccessible(true); //破坏权限无视构造器
        Lazy lazy = declaredConstructor.newInstance(); //反射构造的对象

        System.out.println(instant.hashCode());
        System.out.println(lazy.hashCode());
    }
}

5）如果两个对象都是用单例创建的，通过红绿灯解决

//懒汉式单例
//道高一尺魔高一丈
public class Lazy {

    //红绿灯
    private static boolean bool = false;

    private Lazy(){
        synchronized (Lazy.class){
            if (!bool){
                bool = true;
            }else{
                throw new RuntimeException("不要试图用凡是破坏单例！");
            }
        }

    }

    private volatile static Lazy lazy;

    public static Lazy getLazy(){
        //双重检测锁模式，懒汉式，DCL懒汉式
        if (lazy==null){
            synchronized (Lazy.class){
                if (lazy==null){
                    lazy = new Lazy(); //不是原子性操作，会发生指令重排现象，期望1-2-3
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     * 123
                     * 132 A
                     *     B //此时lazy还没有构造，就返回了
                     *
                     * 所以避免指令重排，要加volatile(原子性操作)
                     */
                }
            }
        }
        return lazy; //此时lazy会有可能未构造
    }

    //反射
    public static void main(String[] args) throws Exception {

        Lazy instant = lazy.getLazy(); //懒汉式中拿到的对象

        Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor(null);//反射获取无参构造器
        declaredConstructor.setAccessible(true); //破坏权限无视构造器
        Lazy lazy = declaredConstructor.newInstance(); //反射构造的对象
        Lazy lazy2 = declaredConstructor.newInstance(); //反射构造的对象
        System.out.println(lazy.hashCode());
        System.out.println(lazy2.hashCode());
    }
}

6）如果红绿灯标志被反射获取，用枚举解决

//懒汉式单例
//道高一尺魔高一丈
public class Lazy {

    //红绿灯
    private static boolean bool = false;

    private Lazy(){
        synchronized (Lazy.class){
            if (!bool){
                bool = true;
            }else{
                throw new RuntimeException("不要试图用凡是破坏单例！");
            }
//            if (lazy!=null){
//                throw new RuntimeException("不要试图用凡是破坏单例！");
//            }
        }

    }

    private volatile static Lazy lazy;

    public static Lazy getLazy(){
        //双重检测锁模式，懒汉式，DCL懒汉式
        if (lazy==null){
            synchronized (Lazy.class){
                if (lazy==null){
                    lazy = new Lazy(); //不是原子性操作，会发生指令重排现象，期望1-2-3
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     * 123
                     * 132 A
                     *     B //此时lazy还没有构造，就返回了
                     *
                     * 所以避免指令重排，要加volatile(原子性操作)
                     */
                }
            }
        }
        return lazy; //此时lazy会有可能未构造
    }

    //单线程下，没有问题，但是多线程会存在问题
//    public static void main(String[] args) {
//        for (int i = 0; i < 10; i++) {
//            new Thread(()->{
//                lazy.getLazy();
//            }).start();
//        }
//    }

    //反射
    public static void main(String[] args) throws Exception {

        Lazy instant = lazy.getLazy(); //懒汉式中拿到的对象

        Field bool = Lazy.class.getDeclaredField("bool"); //反射获取类中的字段
        bool.setAccessible(true); //破坏属性的私有权限

        Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor(null);//反射获取无参构造器
        declaredConstructor.setAccessible(true); //破坏权限无视构造器
        Lazy lazy = declaredConstructor.newInstance(); //反射构造的对象

        bool.set(instant,false); //给字段重新赋值

        Lazy lazy2 = declaredConstructor.newInstance(); //反射构造的对象

        System.out.println(instant.hashCode());
        System.out.println(lazy.hashCode());
        System.out.println(lazy2.hashCode());
    }
}

3、静态内部类实现

//静态内部类实现
public class Holder {

    private Holder(){

    }

    private static Holder getHolder(){
        return InnerClass.holder;
    }

    public static class InnerClass{
        private final static Holder holder = new Holder();
    }
}

4、枚举

//enum: 1.5出现的，本身也是一个class类
public enum EnumSingle {

    INSTANCE;

    public EnumSingle getInstance(){
        return INSTANCE;
    }

    public static void main(String[] args) throws Exception {

        EnumSingle e1 = EnumSingle.INSTANCE;
        
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class, int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle enumSingle = declaredConstructor.newInstance();

        System.out.println(e1);
        System.out.println(enumSingle);
    }
}