11-彻底玩转单例模式

最新推荐文章于 2023-09-06 05:04:22 发布

xixihaha_coder

最新推荐文章于 2023-09-06 05:04:22 发布

阅读量114

点赞数 1

分类专栏： JUC 文章标签： juc

本文链接：https://blog.csdn.net/xixihaha_coder/article/details/120847669

版权

JUC 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

本文探讨了单例模式的三种常见实现方式：饿汉式（即字节数组实例化）、懒汉式（双检锁模式），以及使用枚举确保线程安全。作者详细介绍了每种方法的优缺点和适用场景，并通过示例展示了反射如何影响单例模式的稳定性。

摘要由CSDN通过智能技术生成

20.彻底玩转单例模式

饿汉式 DCL懒汉式

饿汉式

package single;
//饿汉式单例
public class Hungry {
    //一上来就全部加载，浪费空间，
    //那我现在想用的时候再创建，不用就放在那 ，于是乎来了 懒汉式单例
    private byte[] data1=new byte[1024];
    private byte[] data2=new byte[1024];
    private byte[] data3=new byte[1024];
    private Hungry(){

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

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

DCL懒汉式

package single;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class LazyMan {
    private static boolean flag=false;
private LazyMan(){
    synchronized (LazyMan.class){
        if(flag==false){
            flag=true;
        } else {
            throw new RuntimeException("不要试图用反射破坏异常");
        }
    }
}
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.把这个对象指向这个空间
                 * 123
                 * 132 A
                 *     B//此时lazyMan还没有完成构造
                 *
                 */
            }
        }
    }
    return lazyMan;
}
//反射！
    public static void main(String[] args) throws Exception {
    //    LazyMan instance = LazyMan.getInstance();
        Field flag = LazyMan.class.getDeclaredField("flag");
        flag.setAccessible(true);

        Constructor<LazyMan> declaredMethod = LazyMan.class.getDeclaredConstructor(null);
        declaredMethod.setAccessible(true);
        LazyMan instance=declaredMethod.newInstance();

        flag.set(instance,false);
        LazyMan instance2=declaredMethod.newInstance();


        System.out.println(instance); //两个不同，反射可以破坏单例模式
        System.out.println(instance2); //可以解决
}
}

静态内部类

package single;
//静态内部类
public class Holder {
    private Holder(){

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

单例不安全，因为有反射

于是枚举出来了

package 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 NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class, int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();

        System.out.println(instance1);
        System.out.println(instance2);//发现破坏不了
        //java.lang.IllegalArgumentException: Cannot reflectively create enum objects
    }
}