JUC并发：单例模式，双重检测锁，枚举

饿汉式单例

一开始加载全部内存资源，如果一些数据没有被使用，就会造成浪费空间

package com.zgq.single;

//饿汉式==>构造器私有；一开始加载全部内存资源
public class Hungry {
    // 一开始加载全部内存资源,可能会浪费空间
    private byte[] data1 = new byte[1024*1024];
    private byte[] data2 = new byte[1024*1024];
    private byte[] data3 = new byte[1024*1024];
    private byte[] data4 = new byte[1024*1024];
    private Hungry(){
    }
    private final static Hungry HUNGRY = new Hungry();

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

懒汉式单例

package com.zgq.single;

public class LazyManSingle {
    private LazyManSingle(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }

    private static LazyManSingle lazyManSingle;

    public static LazyManSingle getInstance(){
        if(lazyManSingle==null){
            lazyManSingle=new LazyManSingle();
        }
        return lazyManSingle;
    }

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

这个是最简单的懒汉式单例模式，但是这是线程不安全的
测试线程并发：注意看测试结果

使用双重检测锁+原子性操作，也叫DCL懒汉式

使用synchronized 关键字进行上锁，并使用volatile关键字进行原子性操作，避免避免指令重排

package com.zgq.single;

public class LazyManSingle {
    private LazyManSingle(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }

    private static LazyManSingle lazyManSingle;

    public volatile static LazyManSingle getInstance(){
//        if(lazyManSingle==null){
//            lazyManSingle=new LazyManSingle();
//        }
//        return lazyManSingle;
        if (lazyManSingle==null){
            synchronized (LazyManSingle.class){
                if (lazyManSingle==null){
                		 /**
                     * new LazyManSingle();需要经历如下三步
                     * 1. 分配内存空间
                     * 2、执行构造方法，初始化对象
                     * 3、把这个对象指向这个空间
                     * 会发生指令重排现象
                     * 123
                     * 132 A
                     *     B进来 // 认为LazyMan不为空，直接返回，但此时lazyMan还没有完成构造
                     */
                    lazyManSingle=new LazyManSingle();//必须是原子性操作
                }
            }
        }
        return lazyManSingle;
    }

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

这样的话就暂时是线程安全的，但还是会出问题,，因为可以使用反射去破坏单例，通过反射创建对象，就可以破坏单例

//得到空参构造器
 Constructor<LazyMan> declaredConstructor =
         LazyMan.class.getDeclaredConstructor(null);
 //无视私有
 declaredConstructor.setAccessible(true);
 //通过反射创建对象
 LazyMan instance1 = declaredConstructor.newInstance();

可以通过红绿灯标志位+构造函数加锁的方式可以暂时解决

//避免被反射破坏，设置红绿灯/标志位
//避免在不new 对象时，纯粹通过反射来构造对象的情况
private static boolean guoqing = false;

private LazyMan(){
    //防止通过反射破坏单例
    synchronized (LazyMan.class){
        if(guoqing ==false){
            guoqing =true;
        }else {
            throw new RuntimeException("不要试图使用反射破坏异常");
        }
    }
}

但是如果这个标志位被别人破译出来了，一样可以用反射破坏，直接利用反射设置这个值

//通过反射破坏单例模式,任何私有关键字都是纸老虎，不安全
 public static void main(String[] args) throws Exception {
     //LazyMan instance = LazyMan.getInstance();
     //破坏红绿灯标志位
     Field guoqing = LazyMan.class.getDeclaredField("guoqing");
     //破坏私有权限
     guoqing.setAccessible(true);
     //得到空参构造器
     Constructor<LazyMan> declaredConstructor =
             LazyMan.class.getDeclaredConstructor(null);
     //无视私有
     declaredConstructor.setAccessible(true);
     //通过反射创建对象
     LazyMan instance1 = declaredConstructor.newInstance();
     guoqing.set(instance1,false);
     LazyMan instance2 = declaredConstructor.newInstance();
     //System.out.println(instance);
     System.out.println(instance1);
     System.out.println(instance2);
 }

源码分析

如何避免反射破坏单例？
如果时枚举类型，不能通过反射创建枚举对象

public T newInstance(Object ... initargs)
    throws InstantiationException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException
{
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, null, modifiers);
        }
    }
    //如果时枚举类型，不能通过反射创建枚举对象，此处168384相当于枚举类型
    if ((clazz.getModifiers() & Modifier.ENUM) != 0)
        throw new IllegalArgumentException("Cannot reflectively create enum objects");
    ConstructorAccessor ca = constructorAccessor;   // read volatile
    if (ca == null) {
        ca = acquireConstructorAccessor();
    }
    @SuppressWarnings("unchecked")
    T inst = (T) ca.newInstance(initargs);
    return inst;
}

代码验证：

package com.zgq.single;

import java.lang.reflect.Constructor;

// enum 是一个什么？ 本身也是一个Class类
public enum EnumSingle {
    INSTANCE;

    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

class Test{
    public static void main(String[] args) throws Exception{
        EnumSingle instance1 = EnumSingle.INSTANCE;
        //此处没有空参构造器，使用有参构造
        Constructor<EnumSingle> declaredConstructor =
                EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();
        // NoSuchMethodException: com.zgq.single.EnumSingle.<init>()
        System.out.println(instance1);
        System.out.println(instance2);
        //错误:java.lang.IllegalArgumentException:Cannot reflectively create enum objects
    }
}

运行结果：可以看出，确实不能用反射破坏枚举类型

文章完！！！希望我的文章对大家在技术上能有所帮助