单例模式

最新推荐文章于 2024-07-25 13:59:31 发布
最新推荐文章于 2024-07-25 13:59:31 发布
阅读量104 收藏
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oldwangold/article/details/105049520
版权

单例模式

核心作用：

  • 保证一个类只有一个实例，并且提供一个访问该实例的全局访问点

常见场景：

  • Windows的任务管理器
  • Windows的回收站
  • 项目中，读取配置文件的类，一般也只有一个对象，没必要每次都去new对象读取
  • 网站的计数器一般也会采用单例模式，可以保证同步
  • 数据库连接池的设计一般也是单例模式
  • 在Servlet编程中，每个Servlet也是单例的
  • 在Spring中，每个Bean默认就是单例的
  • ……

优点：

  • 由于单例模式只生成一个实例，减少了系统性能开销
  • 单例模式可以在系统设置全局的访问点，优化共享资源访问
  • 单例模式可以说只要是一个合格的开发都会写，但是如果要讲究，小小的单例模式可以牵扯到很多东西

常见的五种单例模式实现方式：

  • 饿汉式（线程安全，调用效率高，不能延时加载）
  • 懒汉式（线程安全，调用效率不高，可以延时加载）
  • DCL懒汉式（由于JVM底层内部模型原因，偶尔会出现问题，不建议使用）
  • 饿汉式改进：静态内部类式（线程安全，调用效率高，可以延时加载）
  • 枚举单例（线程安全，调用效率高，不能延时加载）
// 饿汉式单例
public class SingletonDemo01 {
    // 1. 私有化构造器
    private SingletonDemo01() {

    }
    
    // 2. 类初始化的时候，立即加载该对象
    private static SingletonDemo01 instance = new SingletonDemo01();
    
    // 3. 提供获取该对象的方法，没有synchronized，效率高
    public static SingletonDemo01 getInstance() {
        return instance;
    }
}

class SingleDemo01Test{
    public static void main(String[] args) {
        SingletonDemo01 instance = SingletonDemo01.getInstance();
        SingletonDemo01 instance2 = SingletonDemo01.getInstance();

        System.out.println(instance == instance2); // true
    }
}

// 懒汉式单例
public class SingletonDemo02 {
    // 1. 私有化构造器
    private SingletonDemo02() {

    }

    // 2. 类初始化的时候，不立即加载该对象
    private static SingletonDemo02 instance;

    // 3. 提供获取该对象的方法，有synchronized，效率较低
    public static synchronized SingletonDemo02 getInstance() {
        if (instance == null) {
            instance = new SingletonDemo02();
        }
        return instance;
    }
}

class SingleDemo02Test{
    public static void main(String[] args) {
        SingletonDemo02 instance = SingletonDemo02.getInstance();
        SingletonDemo02 instance2 = SingletonDemo02.getInstance();

        System.out.println(instance == instance2); // true
    }
}

// DCL懒汉式
public class SingletonDemo03 {
    // 1. 私有化构造器
    private SingletonDemo03() {

    }

    // 2. 类初始化的时候，不立即加载该对象
    private volatile static SingletonDemo03 instance;

    // 3. 提供获取该对象的方法，有synchronized，效率较低
    public static SingletonDemo03 getInstance() {
        if (instance == null) {
            synchronized (SingletonDemo03.class) {
                if (instance == null) {
                    instance = new SingletonDemo03();
                }
            }
        }
        return instance;
    }
    // 1.分配内存
    // 2.执行构造方法
    // 3.指向地址
}

class SingleDemo03Test{
    public static void main(String[] args) {
        SingletonDemo03 instance = SingletonDemo03.getInstance();
        SingletonDemo03 instance2 = SingletonDemo03.getInstance();

        System.out.println(instance == instance2); // true
    }
}

// 静态内部类实现
public class SingletonDemo04 {
    private SingletonDemo04(){}

    private static class InnerClass {
        private static final SingletonDemo04 instance = new SingletonDemo04();
    }

    public static SingletonDemo04 getInstance() {
        return InnerClass.instance;
    }
}

class SingleDemo04Test{
    public static void main(String[] args) throws Exception {
        SingletonDemo04 instance = SingletonDemo04.getInstance();
        SingletonDemo04 instance2 = SingletonDemo04.getInstance();

        System.out.println(instance == instance2); // true

        // 反射机制：可以破坏以上的单例
        Constructor<SingletonDemo04> declaredConstructor = SingletonDemo04.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        SingletonDemo04 instance3 = declaredConstructor.newInstance();
        System.out.println(instance == instance3); // false
        System.out.println(instance.hashCode()); // 1735600054
        System.out.println(instance3.hashCode()); // 21685669
    }
}

在构造时判断，防止反射的破坏

// DCL懒汉式
public class SingletonDemo03 {
    // 1. 私有化构造器
    private SingletonDemo03() {
        synchronized (SingletonDemo03.class) {
            if (instance != null) {
                throw new RuntimeException("不要戏图用缓射来破fuai我们的单例");
            }
        }
    }

    // 2. 类初始化的时候，不立即加载该对象
    private volatile static SingletonDemo03 instance;

    // 3. 提供获取该对象的方法，有synchronized，效率较低
    public static SingletonDemo03 getInstance() {
        if (instance == null) {
            synchronized (SingletonDemo03.class) {
                if (instance == null) {
                    instance = new SingletonDemo03();
                }
            }
        }
        return instance;
    }
    // 1.分配内存
    // 2.执行构造方法
    // 3.指向地址
}

class SingleDemo03Test{
    public static void main(String[] args) throws Exception {
        SingletonDemo03 instance = SingletonDemo03.getInstance();
        SingletonDemo03 instance2 = SingletonDemo03.getInstance();

        System.out.println(instance == instance2); // true

        Constructor<SingletonDemo03> declaredConstructor = SingletonDemo03.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        SingletonDemo03 instance3 = declaredConstructor.newInstance();
        System.out.println(instance == instance3); // false
        System.out.println(instance.hashCode()); // 1735600054
        System.out.println(instance3.hashCode()); // 21685669
    }
}

直接利用反射创建对象，单例模式依旧被破坏

class SingleDemo03Test{
    public static void main(String[] args) throws Exception {
        Constructor<SingletonDemo03> declaredConstructor = SingletonDemo03.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        SingletonDemo03 instance3 = declaredConstructor.newInstance();
        SingletonDemo03 instance4 = declaredConstructor.newInstance();
        
        System.out.println(instance3 == instance4); // false
        System.out.println(instance3.hashCode()); // 1735600054
        System.out.println(instance4.hashCode()); // 21685669
    }
}

在私有化构造器中添加标志位进行判断，可以解决问题

// DCL懒汉式
public class SingletonDemo03 {
    private static boolean flag = false;
    // 1. 私有化构造器
    private SingletonDemo03() {
        synchronized (SingletonDemo03.class) {
            if (flag == false) {
                flag = true;
            } else {
                throw new RuntimeException("不要戏图用缓射来破fuai我们的单例");
            }
         }
    }

    // 2. 类初始化的时候，不立即加载该对象
    private volatile static SingletonDemo03 instance;

    // 3. 提供获取该对象的方法，有synchronized，效率较低
    public static SingletonDemo03 getInstance() {
        if (instance == null) {
            synchronized (SingletonDemo03.class) {
                if (instance == null) {
                    instance = new SingletonDemo03();
                }
            }
        }
        return instance;
    }
}

class SingleDemo03Test{
    public static void main(String[] args) throws Exception {
        Constructor<SingletonDemo03> declaredConstructor = SingletonDemo03.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        SingletonDemo03 instance3 = declaredConstructor.newInstance();
        SingletonDemo03 instance4 = declaredConstructor.newInstance();

        System.out.println(instance3 == instance4); 
        System.out.println(instance3.hashCode()); 
        System.out.println(instance4.hashCode()); 
    }
}

但是仍然存在问题，反射可以通过将flag置为false再进行创建。

由于通过反射获得构造函数，在实例化调用newInstance()方法时，会进行判断，当类型是枚举时，将抛出异常，“不能反射地创建一个枚举对象”。

	@CallerSensitive
    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);
            }
        }
        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;
    }

因此，枚举单例是安全的，可以天然地屏蔽单例被反射带来的破坏。

// 枚举单例
public enum  SingletonDemo05 {
    INSTANCE;

    public SingletonDemo05 getInstance() {
        return INSTANCE;
    }
}

class  SingletonDemo05Test {
    public static void main(String[] args) {
        SingletonDemo05 instance = SingletonDemo05.INSTANCE;
        SingletonDemo05 instance2 = SingletonDemo05.INSTANCE;

        System.out.println(instance == instance2);
    }
}
王加油
关注
专栏目录
43丨单例模式（下）：如何设计实现一个集群环境下的分布式单例模式？1
08-03
单例模式是一种设计模式，旨在确保一个类只有一个实例，并提供全局访问点。在单例模式中，类的构造函数是私有的，防止外部直接创建对象，而是通过静态方法获取该类的唯一实例。单例模式的唯一性通常是在进程范围内，...
JS 设计模式之：单例模式定义与实现方法浅析
11-21
本文实例讲述了JS 设计模式之：单例模式定义与实现方法。分享给大家供大家参考，具体如下： 良好的设计模式可以显著提高代码的可读性，降低复杂度和维护成本。笔者打算通过几篇文章通俗地讲一讲常见的或者实用的设计...
快速理解设计模式：单例模式深入
热门推荐
张彦峰的博客
04-21 169万+
单例模式是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。实现方式介绍分析：饿汉式单例模式+懒汉式单例模式（双重检查锁）+静态内部类实现单例模式+注册式单例模式
【C++】C++ 单例模式总结（5种单例实现方法）
unonoi的博客
11-04 9万+
C++ 单例模式的几种实现方式。
设计模式之单例模式
liang8999的博客
03-17 1023
态域，从而创建SingleStaticClass的实例，由于是静态的域，因此只会在虚拟机装载类的。频繁的创建和销毁时，而且创建或销毁时性能又无法优化，此时单例模式的优。饿汉式在jvm加载类时就会创建全局的实例，实例的引用用final修饰，表示实例创建成功。这个模式的优势在于，getInstance方法并没有被同步，并且只是执行一个静态域的访问，在系统中，若要求一个类只有一个对象，如果出现多个对象就会出现异常，则可以采用单例。2.1）由于单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要。
JAVA设计模式之单例模式
一个本科小生的奋斗史
04-16 99万+
本文继续介绍23种设计模式系列之单例模式。 概念： 　　java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。 　　单例模式有以下特点： 　　1、单例类只能有一个实例。 　　2、单例类必须自己创建自己的唯一实例。 　　3、单例类必须给所有其他对象提供这一实例。　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例...
单例模式和工厂模式
qq_54469537的博客
08-04 1311
这篇博客主要介绍了工厂模式以及单例模式中的两种常见模式：饿汉和懒汉模式
【多线程】单例模式
weixin_62848751的博客
07-25 1325
单例模式是一种经典的设计模式它确保一个类只有一个实例，并提供一个全局访问点来获取该实例。单例模式主要用于控制对某些共享资源的访问，例如配置管理器、连接池、线程池、日志对象等。
C++ 单例模式
qq_43331089的博客
04-22 1万+
C++ 单例模式 一 、单例模式 单例可能是最常用的简单的一种设计模式，实现方法多样，根据不同的需求有不同的写法; 同时单例也有其局限性，因此有很多人是反对使用单例的。本文对C++ 单例的常见写法进行了一个总结, 包括懒汉式、线程安全、单例模板等； 按照从简单到复杂，最终回归简单的的方式循序渐进地介绍，并且对各种实现方法的局限进行了简单的阐述，大量用到了C++ 11的特性如智能指针, magic static，线程锁; 从头到尾理解下来，对于学习和巩固C++语言特性还是很有帮助的。 1、什么是单例 单例 S
Python实现单例模式
bb8886的博客
07-26 8275
Python中单例模式的实现方法和应用场景
单例模式详解
欢迎一起学习交流
04-29 2万+
一、什么是单例模式 单例模式是Java中最简单的设计模式之一。这种类型的设计模式属于创建者模式，它提供了一种访问对象的最佳方式。 这种设计模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一对象的方式，可以直接访问，不需要实例化该类的对象。 二、单例模式的结构 单例类：只能创建一个实例的类 访问类：使用单例类的类 三、单例模式分类 饿汉式：类加载就会导致该单实例对象被创建 懒汉式：类加载不会导致该单实例对象被创...
浅谈Spring单例Bean与单例模式的区别
08-28
"浅谈Spring单例Bean与单例模式的区别" 本文主要介绍了Spring单例Bean与单例模式的区别，通过对比两者的定义、实现机制和应用场景，帮助读者更好地理解这两种概念的异同。 一、单例模式的定义和实现 单例模式是一...
使用单例模式创建学生管理系统（饿汉式、懒汉式）
04-28
单例模式是软件设计模式中的一种，它的主要目的是确保一个类只有一个实例，并提供一个全局访问点。在Java或类似的面向对象编程语言中，单例模式常用于管理共享资源，如数据库连接池、线程池或者配置文件等。在这个...
java 单例模式（懒汉式与饿汉式）
08-29
Java 单例模式（懒汉式与饿汉式） Java 单例模式是一种常用的软件设计模式，在它的可信结构中只包含一个被实例化单例的特殊类。通过单例设计模式可以把整系统中的一个类只有一个实例。单例设计模式又分为两种方式，...
【CSS Tricks】像素风字体、图片
09-17
包含像素风中英文字体，鼠标手势普通状态、点击状态和禁用状态，仅用作技术分享学习研究，不可用于其他用途。
卡瓦牙椅E50life中文使用说明书第一部分.pdf
最新发布
09-17
卡瓦牙椅E50life中文使用说明书第一部分.pdf
ChromiumSetup.exe
09-17
ChromiumSetup.exe
Chain of thought 链式思考赋能Transformer模型解决串行计算难题
09-17
Chain of thought（CoT）使Transformer能够执行串行计算，扩展了它们解决问题的能力，超越了仅限并行的局限性。 增强Transformer的表达能力，特别是对于本质上是顺序问题。 原始问题: 大型语言模型（LLMs）在生成最终答案之前生成中间步骤（连续思考，CoT）时，展现出异常的推理能力。CoT有效性背后的机制尚不清楚，尤其是在zero shot和错误推理场景中。   本文的关键见解: • 在没有CoT的情况下，具有有限精度和多项式(n)嵌入大小的恒定深度Transformer只能解决AC0中的问题 • 通过T步骤的CoT，使用恒定位精度和O(log n)嵌入大小的恒定深度Transformer可以解决任何由大小为T的布尔电路可解决的问题 • CoT大幅提高了低深度Transformer在本质上是串行问题上的准确性   本文的解决方案: • 为通过如下特性解决问题的恒定深度Transformer定义了新的复杂性类CoT[T(n), d(n), s(n), e(n)]： T(n) CoT步骤 d(n) 嵌入大小 s(n) 精度位 e(n) 指数位
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值