设计模式（一）单例模式

饿汉式，DCL懒汉式

1、饿汉式单例

/**
 * 饿汉式单例
 * @author it-小林
 * @date 2021年07月05日 9:05
 */
public class HungryPattern {

    //可能会浪费空间，开辟了空间，却没有使用
    private HungryPattern(){

    }

    private final static HungryPattern hungryPattern = new HungryPattern();

    public final HungryPattern getInstance(){
        return hungryPattern;
    }
}

2、饿汉式单例

（1）存在多线程并发模式，也就是说多线程模式下，会有问题。

/**
 * @author it-小林
 * @date 2021年07月05日 9:11
 */
public class LazyPattern {

    private LazyPattern() {

    }

    private static LazyPattern lazyPattern;

    private static LazyPattern getInstance(){
        if(lazyPattern == null){
            lazyPattern = new LazyPattern();
        }
        return lazyPattern;
    }

    //多线程开发
    public static void main(String[] args) {
        Thread thread1 = new Thread(){
            @Override
            public void run() {
                System.out.println(LazyPattern.getInstance());
            }
        };
        thread1.start();
        Thread thread2 = new Thread(){
            @Override
            public void run() {
                System.out.println(LazyPattern.getInstance());
            }
        };
        thread2.start();
    }
}

（2）双重检测锁模式的 懒汉式单例  DCL懒汉式

注意：synchronized 解决并发问题，但是因为lazyMan = new LazyMan();不是原子性操作(可以分割，见代码注释)，可能发生指令重排序的问题，通过volatil来解决。

• Java 语言提供了 volatile和 synchronized 两个关键字来保证线程之间操作的有序性，volatile 是因为其本身包含“禁止指令重排序”的语义，synchronized 是由“一个变量在同一个时刻只允许一条线程对其进行 lock 操作”这条规则获得的，此规则决定了持有同一个对象锁的两个同步块只能串行执行；

• 原子性就是指该操作是不可再分的。不论是多核还是单核，具有原子性的量，同一时刻只能有一个线程来对它进行操作。简而言之，在整个操作过程中不会被线程调度器中断的操作，都可认为是原子性。比如 a = 1。

/**
 * @author it-小林
 * @date 2021年07月05日 9:11
 */
public class LazyPattern {

    private LazyPattern() {

    }

    private static LazyPattern lazyPattern;

    //双重检测模式的  懒汉式单例   DCL懒汉式
    private static LazyPattern getInstance(){
        if(lazyPattern == null){
            synchronized (LazyPattern.class){
                if(lazyPattern == null){
                    //不是一个原子性操作
                    lazyPattern = new LazyPattern();
                    /**
                     * 1.分配内存空间
                     * 2、执行构造方法，初始化对象
                     * 3、把这个对象指向这个空间
                     */
                }
            }
        }

        return lazyPattern;
    }

    //多线程开发
    public static void main(String[] args) {
        Thread thread1 = new Thread(){
            @Override
            public void run() {
                System.out.println(LazyPattern.getInstance());
            }
        };
        thread1.start();
        Thread thread2 = new Thread(){
            @Override
            public void run() {
                System.out.println(LazyPattern.getInstance());
            }
        };
        thread2.start();
    }
}

3、静态内部类

/**
 * 静态内部类
 * @author it-小林
 * @date 2021年07月05日 19:29
 */
public class Holder {

    //构造器私有
    public Holder() {

    }

    public static Holder getInstance(){
        return InnerClass.HOLDER;
    }

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

}

 4、单例不安全，反射破坏（见注释及main方法中反射破解步骤）

/**
 * @author 林瑞涛
 * @date 2021年07月05日 9:11
 */
public class LazyPattern {

    //红绿等解决通过反射创建对象（反编译可以破解该方法）
    private static boolean bolNew = false;
    private LazyPattern() {
        synchronized (LazyPattern.class){
            if(bolNew == false){
                bolNew = true;
            }else{
                throw new RuntimeException("不要试图使用反射破坏单例");
            }
        }
    }

    //volatile避免指令重排
    private volatile static LazyPattern lazyPattern;


    //双重检测模式的  懒汉式单例   DCL懒汉式
    private static LazyPattern getInstance(){

        if(lazyPattern == null){
            //不是一个原子性操作
            lazyPattern = new LazyPattern();
        }
        return lazyPattern;
    }

    //反射
    public static void main(String[] args) throws NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Field bolNew = LazyPattern.class.getDeclaredField("bolNew");
        bolNew.setAccessible(true);

        Constructor<LazyPattern> declaredConstructor = LazyPattern.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);//无视私有的构造器
        LazyPattern instance1 = declaredConstructor.newInstance();
        bolNew.set(instance1,false);
        System.out.println(instance1);
        LazyPattern instance2 = declaredConstructor.newInstance();

        System.out.println(instance2);
    }
}

枚举：通过反射破解枚举发现不成功：
1、普通的反编译会欺骗开发者，说enum枚举是无参构造
2、实际enum为有参构造（见后面）；
3、通过反射破解枚举会发现抛出异常
Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects at java.lang.reflect.Constructor.newInstance(Constructor.java:417) at com.ph.single.Test.main(EnumSingle.java:19)

//enmu是什么？本身也是一个class类
public enum EnumSingle {
    INSTANCE;
    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

class Test{
    public static void main(String[] args) throws Exception {
        EnumSingle instance = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();

        //java.lang.NoSuchMethodException: com.ph.single.EnumSingle.<init>()
        System.out.println(instance);
        System.out.println(instance2);

    }
}

通过idea和jdk自带的反编译枚举如下：

 

通过JDK反编译枚举的代码如下,  发现枚举其实是有参构造