设计模式-单例模式

单例模式

核心作用：保证一个类只有一个实例，并且提供一个访问该实例的全局访问点

一、饿汉式

1. 构造器私有化（防止直接new）
2. 类的内部创建对象
3. 向外暴露一个静态的公共方法 getlinstance
4. 代码实现

// 饿汉式单例
public class Hungry {

    // 单例模式核心思想：构造器私有
    private Hungry(){

    }
    
    //在类的内部直接创建对象 
    private final static Hungry HUNGRY = new Hungry();

    //提供个公有的方法getInstance可以返回私有对象
    public static Hungry getInstance(){
        return HUNGRY;
    }
}

为了能在静态方法getInstance中返回私有的对象，需要把对象也弄成静态的（静态方法只能访问静态属性），如果方法不是静态方法的话，那么我们调用方法就必须先创建对象了

因为在调用这个类的其他属性或者怎么样的时候，类的静态属性会先运行，所有会先new出对象，这种单例模式的对象通常是重量级对象，可能创建对象，但是没有用，造成浪费

二、DCL懒汉式

1. 扔然先构造器私有化
2. 定义一个static静态属性对象，这次不要直接new出来了（new就饿汉一样）、
3. 提供一个public的static方法getInstance可以返回那个对象

使用的时候才创建对象，但是存在线程安全问题（如果第一个个线程在创建new对象的时候没有创建好，第二个线程判断为空进来又可以new一个对象） 所有我们需要优化：

// 懒汉式单例
public class LazyMan {
    private LazyMan() {
        System.out.println(Thread.currentThread().getName() + "ok");
    }

    private volatile static LazyMan lazyMan; //必须加上volatile 防止指令重拍

    // 双重检测锁模式的懒汉式单例  DCL 懒汉式
    public static LazyMan getInstance() {
        if (lazyMan == null) {    
            synchronized (LazyMan.class) {       //我们先加一层锁来保证只有一个线程进来
                if (lazyMan == null) {
                    lazyMan = new LazyMan();// 不是一个原子性操作
                    /*
                    1、分配内存空间
                    2、执行构造方法，初始化对象
                    3、把这个对象指向这个空间
                                        
                    123
                    132 A
                        B // 此时B线程进来会认为lazyman不为null
                          // 直接返回 此时lazyman 还没有完成构造
                          // 为了避免指令重排必须加上volatile
                       */
                }
            }
        }
        return lazyMan;
    }

    public static LazyMan getInstance() {
        if (lazyMan == null) {
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }  
    }
}

两重检测来避免线程问题（面试必须说到）：

1. 我们在检测为空外面在加上一层检测是否为空，加同步锁。为了让a线程进来的时候还没创建完，b线程又进来判断为空继续创建。
2. 我们加了个volatile。因为我们在new的时候可能出现指令重拍，我们是1先分配内存空间，2执行构造方法，初始化对象。3这个对象指向这个空间。但是也有可能132的顺序，如果132在3的时候又有一个线程b进来，就不会认为这个lazyman为空直接不进最外判断，先返回了对象，那么我们就有问题了。所以要加上volatile

三、静态内部类

// 静态内部类实现单例模式 不安全
public class Holder {
    private Holder(){

    }

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

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

四、反射破解单例

我们发现上面的方法都不安全，因为都可以用反射来破解，道高一尺魔高一丈。

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

    private static  boolean qinjiang = false;

    private LazyMan() {
        if(qinjiang == false){
            qinjiang=true;
        }else{
            throw new RuntimeException("不要试图使用反射破坏异常");
        }
//        synchronized (LazyMan.class){
//            if (lazyMan!=null){
//                throw new RuntimeException("不要试图使用反射破坏异常");
//            }
//        }
//        System.out.println(Thread.currentThread().getName() + "ok");
    }

    private  volatile static LazyMan lazyMan; // volatile 为了避免指令重排

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

                    123
                    132 A
                        B // 此时B线程进来会认为lazyman不为null
                          // 直接返回 此时lazyman 还没有完成构造
                          // 为了避免指令重排
                       */
                }
            }
        }
        return lazyMan;
    }

    // 单线程下确实单例ok,但是多线程并发
    public static void main(String[] args) throws Exception {
        // 反射 可以破环这种单例
//        LazyMan instance = LazyMan.getInstance();
        Field qinjiang = LazyMan.class.getDeclaredField("qinjiang");
        qinjiang.setAccessible(true);


        Constructor<LazyMan> declaredConstructor =LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);//无视私有构造器
        LazyMan  instance=declaredConstructor.newInstance();

        qinjiang.set(instance,false);

        LazyMan  instance2=declaredConstructor.newInstance();

        System.out.println(instance);
        System.out.println(instance2);
    }
}

五、枚举（自带单例模式）

当我们点开newInstance的源码的时候，我们发现

当我们想用反射破坏枚举的单例的时候，他会报错警告我们不能用反射创建枚举对象

// enum 本身也是一个 class 类
public enum  EnumSingle {

    INSTANCE;

    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

class Test{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        //Constructor<EnumSingle> declaredConstructor=EnumSingle.class.getDeclaredConstructor(null);
        // 枚举没有无参构造，只有有参构造
        Constructor<EnumSingle> declaredConstructor=EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();

        // java.lang.NoSuchMethodException: com.kuang.single.EnumSingle.<init> 没有空参的构造方法
        // java.lang.IllegalArgumentException: Cannot reflectively create enum objects  反射不能破坏枚举的单例
        System.out.println(instance1);
        System.out.println(instance2);
    }
}

枚举的最终反编译源码发现枚举没有无参构造，只有有参构造