单例模式（饿汉式，DCL懒汉式）

 单例模式特点：

1. 只允许有一个实例
2. 单例类必须创建自己的唯一的实例
3. 单例类必须向其他对象提供获取这一实例的方法（getInstance（））

饿汉式 

package lin.single;

//饿汉式单例
public class Hungry {
    // 可能会浪费空间
    private byte[] data1 = new byte[1024*1024];
    private byte[] data2 = new byte[1024*1024];

    //构造器私有，别人就无法去new这个对象，保证内存中只有一个对象
    private Hungry(){

    }

    private final static Hungry HUNGRY = new Hungry();

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

懒汉式

package lin.single;

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

    private static LazyMan lazyMan;

    public static LazyMan getInstance(){
        if (lazyMan == null) {
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }
    //单线程下确实单例可以，多线程并发就没用了
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                LazyMan.getInstance();
            }).start();
        }
    }
}

解决多线程并发的情况：双重检测锁模式的 懒汉式单例（DCL懒汉式）

package lin.single;

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

    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;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                LazyMan.getInstance();
            }).start();
        }
    }
}

单例不安全（因为有反射）-----枚举解决

 举例：

package lin.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

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

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

        System.out.println(enumSingle1);
        System.out.println(enumSingle2);
    }
}

结果： 这时候想要用反射去破坏，就会报错（不能反射创建枚举类）

 

枚举没有无参构造，只有有参构造（两个参数） 

枚举类型的最终反编译源码：