单例模式

单例模式是指使用的时候只new一次，即使多次使用这个类，我们只需要new一次就可以，这样就达到了节省空间的效果，

单例模式分为 饿汉式和懒汉式这两个模式

单例模式的无参构造的修饰符必须是 私有的

为了防止调用，声明的类变量的修饰符也必须是 私有的

饿汉式单例模式

饿汉式顾名思义，有一中不理性的意思，而在这里的代码，也有同意。

/**
 * @author Mxhlin
 * @Email [email protected]
 * @Date 2022/09/08/20:40
 * @Version
 * @Description   饿汉式单例
 */
public class Hungry {
    // byte[] b1 = new byte[1024*1024];
    // byte[] b2 = new byte[1024*1024];
    // byte[] b3 = new byte[1024*1024];
    
    // 可能会浪费空间
    private Hungry(){

    }
    private final static Hungry HUNGRY = new Hungry();

    public static Hungry getInstance(){
        return HUNGRY;
    }
}

在执行getInstance()的方法时，就会new一个Hungry的对象，这样会导致，如果 这里的类里面有其他的属性或者声明时也会被构建创造，就会导致浪费资源。

懒汉式单例模式

懒汉式单例模式使用了 双重检测锁模式 ，就是满足一定的条件时才new，这样就会节省不必要的浪费资源。

/**
 * @author Mxhlin
 * @Email [email protected]
 * @Date 2022/09/08/20:07
 * @Version
 * @Description 懒汉式模式 DCL懒汉式
 */
public class LazyMan {

    private LazyMan(){
       
    }
    // 在这里加上volatile 防止返回的LazyMan没有完成构造，而返回一个虚无的空间
    private volatile static LazyMan LazyMan;

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

和懒汉式的区别就是，定义一个LazyMan类的属性，在满足一定条件时，new。 这样进入这个代码就不会直接new，而是看一下内存空间有没有已经new过的，如果有的话就不需要再次new了，直接返回LazyMan这个实例