2021-06-16单例模式详解

最新推荐文章于 2025-12-22 15:57:21 发布

原创最新推荐文章于 2025-12-22 15:57:21 发布 · 55 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

学习专栏收录该内容

135 篇文章

订阅专栏

本文探讨了Java中单例模式的实现方式，包括饿汉式、懒汉式、静态内部类和枚举类。饿汉式确保线程安全但可能导致资源浪费，懒汉式则延迟初始化，但在多线程环境下需考虑同步问题。静态内部类和枚举类提供了更安全且高效的单例实现。同时，文章还提到了反射可能破坏单例的实例化限制。

//饿汉式单例
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;
    }
}

//懒汉式单例
//反射始终有办法破坏单例
public class LazyMan {
       private static boolean panxoapyyuan = false;

    private LazyMan() {


        synchronized (LazyMan.class){
            if (panxoapyyuan==false){
                panxoapyyuan=true;
            }else {
                throw new RuntimeException("不要试图重复创建");
            }

        }
    }

    private volatile static LazyMan lazyMan;  //加volatile 解决 原子性操作,lazyMan 还没有完成构造等问题
    //双重检测锁模式的懒汉式单例 DCL懒汉式
     public static LazyMan getInstance(){
         if (lazyMan==null){
             synchronized (LazyMan.class){
                 if (lazyMan==null){
                      lazyMan = new LazyMan(); //不是一个原子性操作
                 }
             }
         }

         return lazyMan; //此时lazyMan 还没有完成构造
     }
     //单线程下此单例可用
//反射
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
       // LazyMan lazyMan1 = LazyMan.getInstance();
        Constructor<LazyMan> declaredMethod = LazyMan.class.getDeclaredConstructor(null);
        declaredMethod.setAccessible(true);
        LazyMan lazyMan2 = declaredMethod.newInstance();
        LazyMan lazyMan1 = declaredMethod.newInstance();
        System.out.println(lazyMan1);
        System.out.println(lazyMan2);

    }
}

在这里插入图片描述

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

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

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

}

//枚举类，也是class
public enum EnumSingle {
    INSTANCE;
    public EnumSingle getInstance(){
        return INSTANCE;
    }
}
class Test{
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        //EnumSingle instance2= 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);
    }
}